LeetCode | Algorithms| Two Sum

原题链接：https://leetcode.com/problems/two-sum/

题意理解：

题目将随机给出一个数组，和一个数值，要求数组中的两个数之和与给出的数值刚好相等，请给出这两个数的下标构成的数组。

解题思路：

嵌套遍历给出的数组，将遍历中的元素两两相加，记录下相加的值，以及相加时，这两个数的下标构成的数组，然后查找程序给出的数值，找到对应的两个下标构成的数组。

详细：

需要记录的值：元素两两相加得到的结果、这两个元素的下标构成的数组

坑点：

对同一个数组的嵌套遍历中，会出现相加同一个元素的情况，要排除

代码：

public class Solution {
	public int[] twoSum(int[] nums, int target) {
        for (int i = 0, len = nums.length; i < len; i++) {
        	for (int j = 0, len2 = nums.length; j < len2; j++) {
        		if (i != j && nums[i] + nums[j] == target) 
        			return new int[]{i,j};
        	}
        }
        return new int[]{0,0};
    }
}
//运行结果：Runtime: 79 ms, faster than 6.77% of Java online submissions for Two Sum.

优化：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for (int i = 0, len = nums.length; i < len; i++) {
        	for (int j = i + 1, len2 = nums.length; j < len2; j++) {
        		if (nums[i] + nums[j] == target) 
        			return new int[]{i,j};
        	}
        }
        return null;
    }
}
//运行结果：Runtime: 39 ms, faster than 22.74% of Java online submissions for Two Sum.

相比前一个代码的优化处：当前下标的值只与其后面下标的值相加，然后与给出的目标数进行比较

再优化：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
        	for (int j = i + 1; j < nums.length; j++) {
        		if (nums[i] + nums[j] == target) 
        			return new int[]{i,j};
        	}
        }
        return null;
    }
}
// 运行结果：Runtime: 28 ms, faster than 33.01% of Java online submissions for Two Sum.

相比前一个代码的优化处：当与数组的大小比较时，直接使用数组的length属性，不需要重新定义一个变量来存储数组的大小，直接使用数组它本身的属性会更省时。

更换思路：

前面都是使用嵌套循环，时间成本高；如果只遍历一次数组能不能找出这两个数？

想象一下，目标数值一定是数组中的两个数，而且这两个数相加是目标数值，所以，这两个数相对于目标数值是互补的。因此，当我在数组中找到其中第二个数值时，这个数值一定是目标数值减去之前已经找到的第一个中数值，而根据题意，我们必须记录下数值对应的索引；因此，我们必须保证，遍历一遍的过程中，使已经遍历过的数值和其在数组中的下标一一对应，立刻想到使用HashMap这个数据结构。

代码：

class Solution {
    public int[] twoSum(int[] nums, int target) {
    	HashMap<Integer, Integer> map = new HashMap<>();
    	// 这个map用于记录我们已经遍历过的元素和对应的下标，此处先保存下数组的第一个元素和对应的下标0
    	map.put(nums[0], 0);
    	for (int i = 1; i < nums.length; i ++) {
    		// 查看我们先前保存的那些记录中是否含有当前这个数相对于目标数的互补数值
    		if (map.containsKey(target - nums[i])) {
    			// 如果有，则获取那个数的下标，以及当前数的下标，构成int数组返回
    			return new int[] {map.get(target - nums[i]), i};
    		}
    		else {
    			// 如果没有，则将当前的数，保存到我们专门用来记录数值和下标的map中
    			map.put(nums[i], i);
    		}
    	}
    	return null;
    }
}
// 运行结果：Runtime: 7 ms, faster than 63.50% of Java online submissions for Two Sum.

再优化：

class Solution {
    public int[] twoSum(int[] nums, int target) {
    	HashMap<Integer, Integer> map = new HashMap<>();
    	// 这个map用于记录我们已经遍历过的元素和对应的下标，此处先保存下数组的第一个元素和对应的下标0
    	map.put(nums[0], 0);
        int len = nums.length;
    	for (int i = 1; i < len; i ++) {
    		// 查看我们先前保存的那些记录中是否含有当前这个数相对于目标数的互补数值
    		if (map.containsKey(target - nums[i])) {
    			// 如果有，则获取那个数的下标，以及当前数的下标，构成int数组返回
    			return new int[] {map.get(target - nums[i]), i};
    		}
    		else {
    			// 如果没有，则将当前的数，保存到我们专门用来记录数值和下标的map中
    			map.put(nums[i], i);
    		}
    	}
    	return null;
    }
}
// 运行结果：Runtime: 4 ms, faster than 99.31% of Java online submissions for Two Sum.

相比前一个代码的优化处：当与数组的大小比较时，直接使用数组的length属性，但是for循环一共有三个参数，中间那个参数，是每一次循环，都会进行一次使用的，而这里原本是调用数组的length属性，那么多次循环就会有多次调用，我们简化成只调用一次，使用len这个变量来保存这个值，也就是说上一个代码，若循环N次，则调用数组的length属性N次，而这个代码则是循环N次，但只调用数组的length属性1次。这个小细节就是3ms的代价(￣▽￣)／

以上！