LeetCode-两数之和

题目链接 => 戳这里

题目描述：
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解法1：暴力遍历

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] == target - nums[j]) {
                    return new int[]{i, j};
                }
            }
        }
        throw new RuntimeException("no result");
    }
}

这种解法需要注意的是j = i +1 部分，为的是避免重复选择了同个元素；但这种解法显然不优雅，需要O(n^2)的时间复杂度；

解法2：利用哈希映射

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            // 这里需要注意是用num[i]作为key，索引作为value
            map.put(nums[i], i);
        }
        for (int i = 0; i < nums.length; i++) {
            int temp = target - nums[i];
            if (map.containsKey(temp) && map.get(temp) != i) {
                return new int[]{i, map.get(temp)};
            }
        }
        throw new RuntimeException("no result");
    }
}

不过这种方法其实还能处理得更简洁一些，直接在第一次遍历数组的时候返回即可；

解法3：还是利用哈希映射

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

这种解法比较好的地方就是不需要考虑会用到同一个元素，因为每个元素只会被遍历一次；

题外话

看上面我所写的代码，不难发现，每次判断元素是否存在于map中的时候，都会使用containsKey()方法，那么其实能不能用map.get(key) != null的方式来判断元素是否在map中呢？这两种方法有没有性能上的差别呢？我们先看一下hashmap的源码：

public boolean containsKey(Object key) {
    return this.getNode(hash(key), key) != null;
}
public V get(Object key) {
    HashMap.Node e;
    return (e = this.getNode(hash(key), key)) == null ? null : e.value;
}

我们可以看到底层实现都是利用this.getNode方法来进行处理的，所以说性能上它们并没有什么差别。
但是我们在使用的时候却需要注意它们不同的用法，我们首先需要知道的一点是hashmap的key和value都是可以为null的，所以我们是可以设置一个键不为null，但是值为null的键值对的，例如 :

Map map = new HashMap<>();
map.put(1, null);

如果我们判断键值对是否存在于map中的目的是为了取值，那么就不应该使用containsKey，否则就可能取出一个null值导致NPE；在这种情况下应该直接使用map.get(key)!=null来进行判断，随后取值。

那什么时候使用containsKey()比较好呢？

在containsKey和get()都可以使用的场景下，推荐使用containsKey方法。例如在这次的算法题中，入参是一个整数数组，数组元素是不可能为null的，所以我们的map元素也不会出现null的值(当然，这里还是有可能传入int数组都是null，只不过题目限制了不会有那样的入参而已)，这里就可以使用containsKey，又或者我们判断元素是否存在于map中只是为了去重，例如我们在遍历一个有重复元素的数据，但是只希望存入第一次出现的数值，这时候，也可以使用containsKey()；使用containsKey()的好处在于：

• 代码可读性：containsKey一目了然；
• 代码简洁性：无需另外刻意的操作(例如 != null 的比较操作)；