LeetCode 1. 两数之和

题目：

题目地址：https://leetcode-cn.com/problems/two-sum/

问题描述：

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

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

示例:

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

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

我的解题思路：

1.暴力解法

最容易想到的就是双层for循环，遍历元素进行相加，判断和是否等于target，如果是则return这两个下标组成的数组。如果遍历完没有符合的结果，则return null 。

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

• 时间复杂度：O(n²)

• 空间复杂度：O(1)

2.尝试着优化（实际上并没有优化成功）

暴力解法能通过测试，但是性能是最差的，于是尝试着想要优化。

一开始想着的优化思路是减少for循环的次数，想到了如果出现 target>nums[i] 那么nums[i]+nums[j]==target就不成立了，这样就没有必要进入第二层for，这样可以稍微提高性能。于是写下了：

 for (int i = 0; i <nums.length ; i++) {
        //一开始觉得：如果数组中某元素大于target，则没有比较进入第二层for，直接break
        if (nums[i]>target){
            break;
        }
        for (int j = 0; j <nums.length; j++) {
            if (nums[i]+nums[j]==target){
                return new int[]{i,j};
            }
        }
    }
    return null;
}

提交了之后并没有通过。原来忘记考虑测试用例中有负数的存在，觉得应该要用绝对值比较，于是修改如下了：

if (Math.abs(nums[i])>Math.abs(target)){
    break;
}

然而，提交了之后还是没有通过。事实上是我没有考虑到一些复杂的测试用例，上面的写法只能通过nums数组中全是正数或者全是负数的测试用例，而nums数组中既存正整数又存在负数的情况是通过不了的。

于是我的尝试优化失败。

那么还是看看官方给出的解题思路吧。

官方解题思路：

方法一：暴力法

暴力法很简单，遍历每个元素 xx，并查找是否存在一个值与 target - x相等的目标元素。

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[j] == target - nums[i]) {
                    return new int[] { i, j };
                }
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

复杂度分析：

• 时间复杂度：O(n^2)， 对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费 O(n) 的时间。因此时间复杂度为 O(n^2)。

• 空间复杂度：O(1)。

方法二：两遍哈希表

为了对运行时间复杂度进行优化，我们需要一种更有效的方法来检查数组中是否存在目标元素。如果存在，我们需要找出它的索引。保持数组中的每个元素与其索引相互对应的最好方法是什么？哈希表。

通过以空间换取速度的方式，我们可以将查找时间从 O(n)降低到 O(1)。哈希表正是为此目的而构建的，它支持以 近似 恒定的时间进行快速查找。我用“近似”来描述，是因为一旦出现冲突，查找用时可能会退化到 O(n)。但只要你仔细地挑选哈希函数，在哈希表中进行查找的用时应当被摊销为 O(1)。

一个简单的实现使用了两次迭代。在第一次迭代中，我们将每个元素的值和它的索引添加到表中。然后，在第二次迭代中，我们将检查每个元素所对应的目标元素target−nums[i]）是否存在于表中。注意，该目标元素不能是 nums[i]本身！

class Solution {
    public int[] twoSum(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 complement = target - nums[i];
            if (map.containsKey(complement) && map.get(complement) != i) {
                return new int[] { i, map.get(complement) };
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

复杂度分析：

• 时间复杂度：O(n)， 我们把包含有 n个元素的列表遍历两次。由于哈希表将查找时间缩短到 O(1) ，所以时间复杂度为 O(n)。

• 空间复杂度：O(n)， 所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 n 个元素。

方法三：一遍哈希表

事实证明，我们可以一次完成。在进行迭代并将元素插入到表中的同时，我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回。

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

• 复杂度分析：时间复杂度：O(n)， 我们只遍历了包含有n 个元素的列表一次。在表中进行的每次查找只花费 O(1)的时间。

• 空间复杂度：O(n)， 所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 n 个元素。

总结：

1. 要仔细读题。

   题目中写道：”你不能重复利用这个数组中同样的元素。“在官方解题中第二层for循坏是 j=i+1 起始，而我自己写的是普通的 j=0 起始，这样做了很多次无用的循坏。

   没有仔细读题，写个暴力法的性能都比官方题解写的差。

2. 关于返回结果

   当没有符合预期的结果时，我一开始使用的是 return null。但是这其实并不是一个好的编程习惯，在开发中，这种做法会把问题丢给方法的调用者，容易造成NPE。更好的做法应该是像官方题解中一样，throw出异常。

3. 要尽可能的考虑更多的测试用例情况。

4. 哈希表的妙用

   哈希表用空间换时间，能将查找时间从 O(n)降低到 O(1)，查找的性能非常优秀。

最后：

第一次刷LeetCode，虽然是简单的题目，但还是暴露了很多问题。但正是遇见问题，才会有收获。