LeetCode每日一题：1. 两数之和原创

努力的IT小胖子

发布于 2022-1-18 08:15

浏览

1收藏

春节不停更，此文正在参加「星光计划-春节更帖活动」

LeetCode每日一题：1. 两数之和

题目描述

给定一个整数数组nums和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

官网链接

1. 两数之和

示例

示例1

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
1.
2.
3.

示例2

输入： nums = [3,2,4], target = 6
输出： [1,2]
1.
2.

示例3

输入： nums = [3,3], target = 6
输出： [0,1]
1.
2.

解决方法

暴力循环法

第一次根据题目就是很简单，把数组中的所有数、两两组合在一起，并计算它们的和，如果计算的和是等于target，那么就输出。

代码

public int[] twoSum01(int[] nums, int target) {
    int len = nums.length;
    for (int i = 0; i < len - 1; i++) {
        for (int j = i + 1; j < len; j++) {
            if (nums[i] + nums[j] == target) {
                return new int[]{i, j};
            }
        }
    }
    return new int[0];
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

复杂度分析

通过代码得知，暴力循环法是由两个for循环组成，所以暴力循环法的时间复杂度是O(n^2)，对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费O(n)。

空间复杂度因为没有产生额外的空间，最多就是一些常量级别的定义，所以暴力循环法的空间复杂度是O(1)。

两遍哈希表

通过方法一得知，如果需要得到两数之和，那么就要遍历所有的数组元素，效率很低下，为了对运行时间复杂度进行优化，我们需要一种更有效的方法来检查数组中是否存在目标元素。如果存在，我们需要找出它的索引。这可以使用哈希表来实现。

在第一次迭代中，我们将每个元素的值和它的索引添加到表中；然后，在第二次迭代中，我们将检查每个元素所对应的目标元素(target-nums[i])是否存在于表中。

代码实现

public int[] twoSum02(int[] nums, int target) {
    int len = nums.length;
    Map<Integer, Integer> map = new HashMap<>(len);
    for (int i = 0; i < len; i++) {
        map.put(nums[i], i);
    }
    for (int i = 0; i < len; i++) {
        int value = target - nums[i];
        if (map.containsKey(value) && map.get(value) != i) {
            return new int[]{i, map.get(value)};
        }
    }
    return new int[0];
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

复杂度分析

通过代码得知，两遍哈希表是由两个for循环相加得到，而每一个for循环的时间复杂度是O(N)，我们把包含有N个元素的列表遍历两次。由于哈希表将查找时间缩短到O(1)，所以时间复杂度为O(N)

因为声明了一个HashMap表，所以所需的额外空间取决于哈希表中存储的元素数量，所以两遍哈希表的空间复杂度是O(N)。

一遍哈希表

通过方法二得知，如果在进行迭代并将元素插入到表中的同时，我们可以直接检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回。这样，只需要扫描一次哈希表，就可以完成算法了。

代码实现

public int[] twoSum03(int[] nums, int target) {
    int len = nums.length;
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < len; i++) {
        int value = target - nums[i];
        if (map.containsKey(value)) {
            return new int[]{map.get(value), i};
        } else {
            map.put(nums[i], i);
        }
    }
    return new int[0];
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.