声明：
简单难度的题基本都不看答案，使用自己的方法来做，如果引用了他人的代码将会有所标注。
简单难度的题虽然基本一看就有思路，但是实际编写代码的过程中会出现各种问题，尤其是边界问题，所以大多代码并不是一次写成的，而是使用idea的代码调试功能多次尝试后修改成功的。
1、两数之和
思路：先固定第一个数，然后找到第二个数使得两个数相加等于target，一旦找到这样的两个数，就直接返回结果，不再循环。由于给定的测试数据必然会有答案，所以无需考虑找不到这样两个数的情况。
代码：
public int[] twoSum(int[] nums, int target) {
int ret[] = new int[2];
boolean flag = true;
for (int i = 0; i < nums.length && flag; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (nums[i] + nums[j] == target) {
ret[0] = i;
ret[1] = j;
flag = false;
break;
}
}
}
return ret;
}
7、整数反转
思路：首先将整数转换为字符串，然后以字符串中间为对称轴，将对称部分的数字替换；如果是负数，则下标从1开始，否则下标从0开始。最后将字符串转换为整数，此时判断转换后的数字如果大小溢出，则返回0，否则返回反转后的整数。
代码：
public int reverse(int x) {
if (x == 0)
return 0;
boolean fu = false;
String str = new Integer(x).toString();
if (str.length() == 1)
return x;
// 提取负号
try {
str = str.substring(str.indexOf('-'), str.length());
fu = true;
} catch (Exception e) {
}
String strpost = new String();
while (true) {
try {
strpost = str.substring(0, str.lastIndexOf('0'));
} catch (Exception e) {
}
if (strpost.length() + 1 != str.length())
break;
str = strpost;
}
char[] chars = str.toCharArray();
for (int i = fu ? 1 : 0, j = str.length() - 1; i <= (str.length() - 1) / 2; i++, j--) {
char tag = chars[j];
chars[j] = chars[i];
chars[i] = tag;
}
int result = ((Double) Double.valueOf(new String(chars)) > Math.pow(2, 31) - 1) || ((Double) Double.valueOf(new String(chars)) < Math.pow(-2, 31)) ? 0 : (int) Integer.valueOf(new String(chars));
return result;
}
9、回文数
思路：
如果是负数，一定不是回文数
令x为输入的数，sum为回文数，最后直接返回判断x==sum即可
生成sum的方法：
·首先令y=x
·每次获取y的倒数第i位，当做sum的正数第i位
·使用模运算完成上述功能
代码：
public boolean isPalindrome(int x) {
if(x<0)
return false;
int y = x;
int sum = 0;
while (y > 0) {
sum = sum * 10 + y % 10;
y=y/10;
}
// if (x == sum)
// return true;
// else
// return false;
return x==sum;
}
13、罗马数字转整数
思路：直接case IVXLCDM这些字母的值加入到sum中。但需要处理额外的6种情况：IV、IX、XL、XC、CD、CM。因此在处理I、X、C这三种情况时，需要看一下他们的下一位是不是分别处于这些情况中。
代码：
public int romanToInt(String s) {
int sum = 0;
char[] str = s.toCharArray();
for (int i = 0; i < str.length; ) {
switch (str[i]){
case 'I':
try {
switch (str[i+1]){
case 'V':
sum+=4;
i+=2;
break;
case 'X':
sum+=9;
i+=2;
break;
default:
sum+=1;
i+=1;
}
}catch (Exception e){
sum+=1;
i+=1;
}finally {
break;
}
case 'X':
try {
switch (str[i+1]){
case 'L':
sum+=40;
i+=2;
break;
case 'C':
sum+=90;
i+=2;
break;
default:
sum+=10;
i+=1;
}
}catch (Exception e){
sum+=10;
i+=1;
}finally {
break;
}
case 'C':
try {
switch (str[i+1]){
case 'D':
sum+=400;
i+=2;
break;
case 'M':
sum+=900;
i+=2;
break;
default:
sum+=100;
i+=1;
}
}catch (Exception e){
sum+=100;
i+=1;
}finally {
break;
}
case 'V':
sum+=5;
i+=1;
break;
case 'L':
sum+=50;
i+=1;
break;
case 'D':
sum+=500;
i+=1;
break;
case 'M':
sum+=1000;
i+=1;
break;
default:
System.out.println("你输入的不是罗马字符");
}
}
return sum;
}
14、最长公共前缀
这道题记得调试了好久，关键在于输入字符串中可能有0个或多个空的字符串以及变量j的下标问题
思路：
·首先获取输入字符串中最短的字符串长度用作循环遍历的终止条件，然后从下标0开始对所有字符串下标为0的地方遍历。一旦遇到哪个下标对应的字符不同，则跳出循环。
·循环终止后，截取子串作为返回值，截取子串时，如果是因为有字符不等而提前终止，则j=j-2；如果是因为所有字符全部相等，则最后j=j-1.
·如何理解呢？因为如果循环结束是因为跳出循环导致的，则跳出循环后j-1这个位置的字符是不同的，而如果循环结束是因为j==length导致的，说明j-1这个位置的字符都是相同的，所以只减去了1.由于substring函数是左闭右开的，因此这个函数的第二个参数为j+1。
代码：
public String longestCommonPrefix(String[] strs) {
String cop = new String();
// 求最短length
if (strs.length == 0)
return "";
if (strs.length == 1)
return strs[0];
int length = strs[0].length();
if (length == 0) // 防止报错 先判断一次
return "";
for (int i = 0; i < strs.length - 1; i++) {
if (length > strs[i + 1].length())
length = strs[i + 1].length();
}
if (length == 0) // 如果所有字符串中有一个为空，则直接返回空
return "";
boolean b = true;
int j;
char[] chars = new char[strs.length];
for (j = 0; j < length && b; j++) {
chars[0] = strs[0].charAt(j);
for (int i = 1; i < strs.length; i++) {
chars[i] = strs[i].charAt(j);
if (chars[i] != chars[i - 1]) {
b = false;
break;
}
}
}
j-=1;
if(!b){
j-=1;
}
cop = strs[0].substring(0, j + 1);
return cop;
}
20、有效的括号
思路：考研数据结构基础题，使用栈即可
代码：
public boolean isValid(String s) {
Stack stack = new Stack();
for(int i = 0;i<s.length();i++){
try {
switch (s.charAt(i)) {
case ')':
if ((char) stack.pop() != '(')
return false;
break;
case ']':
if ((char) stack.pop() != '[')
return false;
break;
case '}':
if ((char) stack.pop() != '{')
return false;
break;
default:
stack.push(s.charAt(i));
}
}catch (Exception e){
return false;
}
}
if(stack.empty())
return true;
return false;
}
21、合并两个有序链表
考研数据结构基础题，没难度，直接写
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if(l1==null&&l2==null)
return null;
ListNode l3 = new ListNode();
ListNode p = l3;
while (l1 != null && l2 != null) {
if (l1.val < l2.val) {
p.val = l1.val;
l1 = l1.next;
} else {
p.val = l2.val;
l2 = l2.next;
}
p.next = new ListNode();
p = p.next;
}
while (l1 != null) {
p.val = l1.val;
if (l1.next != null)
p.next = new ListNode();
l1=l1.next;
p=p.next;
}
while (l2 != null) {
p.val = l2.val;
if (l2.next != null)
p.next = new ListNode();
l2=l2.next;
p=p.next;
}
return l3;
}
}
26、原地删除排序数组中的重复项
思路：要求不能使用额外的空间，因此使用两个指针，第一个指针用于放置数组中不同的元素，第二个指针用于遍历整个数组。
代码：
public int removeDuplicates(int[] nums) {
if(nums.length==0)
return 0;
int i ,count=1;
for(i=0;i<nums.length-1;i++){
if(nums[i]!=nums[i+1])
nums[count++]=nums[i+1];
}
return count;
}
27、移除元素
思路：又是原地移除元素，如果每删除一个元素就把后面的所有元素前移一个，那时间复杂度也太高了。所以当遇到要删除的元素的时候，把倒数第count++个元素直接覆盖掉要删除的元素就可以了，count初始为1.最后返回移除元素后的数组中的数字个数n，判题的时候它会自动只取前n个元素进行检验。
代码：
public int removeElement(int[] nums, int val) {
int i, k;
int count = 1, n = 0;
int length = nums.length;
if (length == 0)
return 0;
if (length == 1) {
if (nums[0] == val)
return 0;
else
return 1;
}
for (i = 0, k = 0; k < length; i++, k++) {
if (nums[i] == val) {
nums[i] = nums[nums.length - count];
i--;
count++;
} else {
n++;
}
}
return n;
}
28、实现strStr()
题目要求找出needle字符串在haystack字符串中出现的第一个位置，如果不存在则返回-1
思路：先固定haystack的起始位置index，然后一个一个字符去比较needle，如果从index开始的字符全部和needle相等，则说明找到了，返回index，如果中途被中断了，则从index+1的位置开始重新找，如果找到最后也找不到，则返回-1.
代码：
public int strStr(String haystack, String needle) {
if (needle.length() == 0)
return 0;
if (needle.length() > haystack.length())
return -1;
int i, j, index = -1;
for (i = 0, j = 0; i < haystack.length() && j < needle.length(); i++) {
if (haystack.charAt(i) == needle.charAt(j) && index == -1) {
index = i;
j++;
} else if (haystack.charAt(i) == needle.charAt(j) && index != -1) {
j++;
} else {
if (index != -1)
i=index;//这个字符串的当前位置不对了，也许该字符正好是needle的第一个字符
index = -1;
j = 0;
}
}
if(j==needle.length())
return index;
return -1;
}
35、搜索插入位置
思路：
本质就是二分法插入排序中的一步，需要注意边界问题
代码：
public int searchInsert(int[] nums, int target) {
int i = 0, j = nums.length - 1;
int k;
while (i < j) {
k = (i + j) / 2;
if (target > nums[k]) {
if (i != k)
i = k;
else i = k + 1;
} else if (target < nums[k]){
if (j != k)
j = k;
else j = k - 1;
}
else return k;
}
if (nums[i] < target)
return i + 1;
else return i;
}
来源：oschina
链接：https://my.oschina.net/u/4287583/blog/4702413