声明：
简单难度的题基本都不看答案，使用自己的方法来做，如果引用了他人的代码将会有所标注。
简单难度的题虽然基本一看就有思路，但是实际编写代码的过程中会出现各种问题，尤其是边界问题，所以大多代码并不是一次写成的，而是使用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、合并两个有序链表

考研数据结构基础题，没难度，直接写

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;
    }