因为上一张墨迹了好多，加上那道题是中等难度的，我自己捋思路也比较墨迹，不过今天刷的都是简单的，很容易理解啦。
目前个人计划是一天刷3——5题左右。

两数之和

这个其实我觉得是最简单的一个，虽然我的答案也不怎么好（看了解析才觉得自己想法贼麻烦）

题目：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

思路：这个题其实很好理解，然后我一开始审题就定了两个思路：一个是遍历数组两两相加，直到结果是target为止，另一个就是把target拆分成两个数字，一组组去数组判断，直到某组存在为止。
下面的是我没有看解析的 代码：

    public int[] twoSum(int[] nums, int target) {
        //两种思路：首先因为nums是整数数组，target也是整数，所以一种是nums中两两相加，当结果为target时找到了想要的 ，另一种target拆分都可以？+？，判断这两个数字是否在nums中都存在，如果遇到都存在的，也找到了想要的答案。
    int length = nums.length;
    int[] result = new int[2];
    //遍历数组，两两相加
    for(int i = 0;i<length;i++){
        //因为i是从第一个开始循环，所以j直接从第二个开始就可以了，毕竟一个数只能用一次
        for(int j=1;j<length;j++){
            if(i==j){
                //因为一个数只能用一次，所以i==j说明是同一个数，所以直接跳出、
                continue;
            }
           if(nums[i]+nums[j]==target){             
               result[0]=i;
               result[1]=j;
               //！！！这个很重要，在匹配到之后直接返回，不然继续循环肯定这两个数会反过来
               return result;
           }
        }
    }
     return result;
    }

然后勉强多次踩坑完成了功能的实现，（主要坑在了1，i和j相同的那个continue还有直接找到结果就return这两点）
再之后看人家的题解，感觉我写的还是需要历练吧。很多细节的优化我都没想到。比如上文的第二个循环j，我是从1开始，还自以为已经优化了，其实还有更好的解法：就是我们只需要把i和往后的数字比较就好了，所以j的取值完全可以是i+1。这样在数字多的时候，可以省去大部分没用的判断。

优化后的代码

    public int[] twoSum(int[] nums, int target) {
        //两种思路：首先因为nums是整数数组，target也是整数，所以一种是nums中两两相加，当结果为target时找到了想要的 ，另一种target拆分都可以？+？，判断这两个数字是否在nums中都存在，如果遇到都存在的，也找到了想要的答案。
    int length = nums.length;
    int[] result = new int[2];
    Map<Integer,Integer> map = new HashMap<Integer,Integer>();
    for(int i=0;i<length;i++){
        //遍历数组，这个说起来有点绕，但是大概就是把每一个数字存为map 的key，下标存为value。
        //存的同时用target减去这个数，如果结果在map中已经存在了则说明这两个数相加是target，
        //然后把这两个数的下标取出来存在result中返回
        //如果数据库中有这个数的另一半则直接进到if中
       if(map.containsKey(target-nums[i])){
           result[0] = map.get(target-nums[i]);
           result[1] = i;
          return result;
       }else{
           //map中没有这个数的另一半，所以把这个数存起来。
           map.put(nums[i],i);
       }
    }
     return result;
    }

其实这个要说下题外话，这两种方式都是我想出来的，但是！！！看了大佬们的题解之后我反而更加懵了，因为什么时间复杂度，哈希碰撞什么的，我都快怀疑看了个假题了。
我目前水平有限，什么是好？代码简洁易懂，什么是性能好？字面上看没有大循环小循环，一层又一层循环就是好。就比如这两种方法，明显第一种可能执行的代码要比第二种多得多，这不就是好么。多了不说了，这道题比较简单，继续下一题。

整数反转

这个题真的，一下子又怀疑人生了，心态太炸了。

题目：给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

思路：我不知道是我真的傻还是确实是思维方式没练出来，第一反应这道题两个关键点：正负数，溢出。
然後写了一堆贼SB的代码：

public int reverse(int x) {
        String s = x+"";
        String[]  arr = s.split("");
        int length =arr.length;
        String result = "";
        boolean flag = false;
        for(int i =0;i<length;i++){
            if("-".equals(arr[i])){
                flag = true;
            }
           //最后一个元素就是length-1。
           result += arr[length-1-i]; 
        }
        //如果是负数则最后一个是-
        if(flag){
           result = result.replaceAll("-","");
           result = "-"+result;
        }
        //将字符串转成int ，如果溢出会报错，则返回0
        try{
            int r = Integer.parseInt(result);
            return r;
        }catch(Exception e){
            return 0;
        }       
    }

然後看题解：人家大佬真真正正的三行逻辑代码，再多的是符号和定义了。要说多深奥也就罢了，没接触到的知识不会还能安慰安慰自己，但是其实看过之后很容易懂，只能觉得自己怎么就想不到？！！
贴上大佬的代码（这段代码）:

    public int reverse(int x) {
        long rs = 0;
        while(x != 0){
            rs = rs*10+x%10;
            x /= 10;
        }
        return (rs<Integer.MIN_VALUE || rs>Integer.MAX_VALUE) ? 0:(int)rs;
    }

看看人家的逻辑！！！重点是while里面的判断。x%10获取的是参数的尾数，x /= 10因为X是int型，所以自动舍弃尾数，不用考虑四舍五入。获取的就是最后一位。然后rs10，在第一位数无效，因为rs是0,0乘以十还是0，但要是别的位10以后自动把最后一位空了出来。
整体总结：看了能看懂，自己想想不出来。
我觉得这个就是思路的重要性。
全文手打，对你有帮助麻烦点个喜欢点个关注啥的，也祝大家工作顺顺利利！