Leetcode 1.Two Sum

Leetcode 1.Two Sum

一、题目描述

这是 Leetcode 上面的第一题，非常的经典，在面试中也十分常见。

难度：easy 标签：数组 哈希表

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

二、自己的解法

很容易想到的解法是：两层 for 循环，找到了直接退出，或者遍历完未找到。代码如下：

private static int[] twoSum1(int[] data, int target){
    for (int i = 0; i < data.length - 1; i++) {
        for (int j = i + 1; j < data.length; j++) {
            if (data[i] + data[j] == target){
                return new int[]{i, j};
            }
        }
    }
    throw new IllegalArgumentException("No such two elements in array");
}

复杂度分析： 最好情况下，数组第一个和第二个元素就是目标值，那么时间复杂度是 O(1)，最坏情况下，外层遍历 n 次，里层遍历 n 次，因此时间复杂度是 O(n²)，平均情况下的时间复杂度也是 O(n²)。

空间复杂度：由于未借助额外的存储空间，因此空间复杂度是 O(1)。

运行结果： 时间击败 36%，空间击败 98%。是一个很一般的解法，时间复杂度较高。

三、官方题解

1. 暴力解法

和上面我自己的解法思路是一样的，不再赘述。

2. 使用哈希表，两次遍历

这里借助了一个哈希表，首先遍历一次，将数组中的元素放入哈希表中。key 是数值，value 是数值在数组中的下标。

然后再次遍历数组，使用目标值减去当前值得到差值 k，然后在哈希表中查询 k 是否存在，如果存在则直接返回，否则继续遍历数组。

这里体现了利用哈希表等值查询的优势，在某些特定的场合可以借助哈希表来降低时间复杂度

实现代码如下：

private static int[] twoSum2(int[] nums, int target){
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        map.put(nums[i], i);
    }

    for (int i = 0; i < nums.length; i++) {
        int k = target - nums[i];
        if (map.containsKey(k) && map.get(k) != i){
            return new int[]{i, map.get(k)};
        }
    }
    throw new IllegalArgumentException("No such two elements in array");
}

复杂度分析： 两次线性遍历数组，时间复杂度是 O(n)，因为使用了一个哈希表，其空间不会超过数组的大小，因此空间复杂度是 O(n)。

运行结果： 时间击败 98%，空间击败 98%（感觉不太合理）。是一个很好的解法。

3. 使用哈希表，一次遍历

针对上面的解法，其实可以进行优化，遍历数组的时候，先将数值存放到哈希表中，在往后遍历时，求得和目标值的差值 k，如果 k 存在哈希表中，则返回结果。这样只需要遍历一次就能够求得结果。代码如下：

private static int[] twoSum3(int[] nums, int target){
    Map<Integer, Integer> map = new HashMap<>();

    for (int i = 0; i < nums.length; i++) {
        int k = target - nums[i];
        if (map.containsKey(k)){
            return new int[]{i, map.get(k)};
        }
        map.put(nums[i], i);
    }

    throw new IllegalArgumentException("No such two elements in array");
}

复杂度分析： 一次线性遍历数组，因此时间复杂度是 O(n)，因此借助了哈希表，因此空间复杂度是 O(n)。

运行结果： 时间击败 98%，空间击败 98%，虽然运行的效果和上面的解法是一样的，但是理论上这才是最优解法，因此相比上面的解法，少了一次线性遍历。