算法-两数之和（简单）

原题：

        给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

分析：

        这个题目很容易就会让人想起来两个for循环去遍历数组，找到符合条件的一组数据，输出下标。这还不简单，分分钟就建个Class自己要亲自上去试一下ta的深浅。

class Solution {

}

         类建好了，再来写个方法吧，入参两个，一个数组，一个目标整数；返回参数就是一个数组吧，用来装两个数的数组下标，分分钟就给写好，快的一逼

class Solution {
        public int[] twoSum(int[] nums, int target){
           
        }
}

         到这里了，应该是要写那两个for循环了，思考一下，第一层就是从数组第一个数字num[i]开始遍历，第二层就是从这num[i]后面的数字开始，看看跟num[i]是不是加起来等于目标数字target。

class Solution {
        public int[] twoSum(int[] nums, int target){
            for(int i = 0; i <= nums.length; i++){
                
            }
            
            return null;
        }
}

        写到这里，感觉这个i<=nums.length需要优化一下，首先看起来有下标越界的嫌疑，i是从0开始的，最大值应该是取到nums.length-1,先优化一波，i小于nums.length的值就可以了，不用小于等于。

class Solution {
        public int[] twoSum(int[] nums, int target){
            for(int i = 0; i < nums.length; i++){
                
            }
            
            return null;
        }
}

        其次，第一层循环最多取到数组的倒数第二个数字，倒数第一个数字不用取，因为倒数第一个数字，根本没有更后面的数字去跟他做加法运算了，而num.length属性，是获取到数组的元素个数，所以，i应该最大能取的数，是小于num.length - 1;

​
class Solution {
        public int[] twoSum(int[] nums, int target){
            for(int i = 0; i < nums.length - 1; i++){
                
            }
            
            return null;
        }
}

​

        第一层for循环就先写成这样了，下面开始写第二层循环，第二层循环是从第一层循环的后面一个数字开始，所以j的起始下标应该是i+1;但是j可取到数组最后一个数字，所以终止条件是j<nums.length就行了。

class Solution {
    public int[] twoSum(int[] nums, int target){
        for(int i = 0; i < nums.length - 1; i++){
            for(int j = i + 1; j < nums.length; j++){
                
            }
        }
        return null;
    }
}

        第二层循环里面，直接判断里面nums[i] + nums[j]的和等不等于target就完事儿了，等于就直接输出，不等于就继续循环

class Solution {
    public int[] twoSum(int[] nums, int target){
        for(int i = 0; i < nums.length - 1; i++){
            for(int j = i + 1; j < nums.length; j++){
                if (nums[i] + nums[j] == target) {
                    return new int[]{i, j};
                }
            }
        }
        return null;
    }
}

        代码优化一下，没有合适的结果，返回个null多少不太合适的，还是返回一个空数组吧。

class Solution {
    public int[] twoSum(int[] nums, int target){
        for(int i = 0; i < nums.length - 1; i++){
            for(int j = i + 1; j < nums.length; j++){
                if (nums[i] + nums[j] == target) {
                    return new int[]{i, j};
                }
            }
        }
        return new int[0];
    }
}

        这样两层for循环的解题算法就写好了，力扣上提交了一下，成功了。总觉得这种暴力遍历的方法，应该不是最优解，瞅一眼别人的解题思路，竟然有天才想到用哈希表来解决这个问题，哈希表的查询时间复杂度是O(1)，而for循环的时间复杂度是O(n)，很明显，在上面的第二层循环中，如果用哈希表的方式查询数字，会比for循环的查询效率更优秀。

        这么好的法子，跟着效仿一下，第一层for循环外要声明一个map，用来装载待查询的数字，这里不是打算把数组复制到map里面然后查询，这样首先还要把数字遍历并copy一份到map里，这个copy的过程，对查询没有实际的帮助，搞算法嘛，最好就是每一次遍历都做更多的事儿，所以这里的操作是：

        一、第一层遍历的时候，取到当前的这个数字nums[i]，查询map里是否包含有一个数字满足跟nums[i]相加等于target。这就相当于抓了别人老婆，找老公来认领，map的查询速度非常快，相比两层for循环的查询方法，这个第二层查询省了不少时间。

        二、如果不包含，就把这个nums[i]放进map里面。相当于把数据放进map操作，只不过我们在放入的时候干了更多的事儿。

        三、如果包含，就返回这一对数据。

import java.util.HashMap;
import java.util.Map;

class Solution {
    public int[] twoSum(int[] nums, int target){
        Map<Integer, Integer> map= new HashMap<Integer, Integer>();
        for(int i = 0; i < nums.length; ++ i){
            if (map.containsKey(target - nums[i])) {
                return new int[]{map.get(target - nums[i]), i};
            }
            map.put(nums[i], i);
        }
        return new int[0];
    }
}

        以上就是力扣第一题的两种解题保姆级思考过程了，有帮助的话就赏个攒吧。