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

发布于 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] 。
  • 示例2
输入: nums = [3,2,4], target = 6
输出: [1,2]
  • 示例3
输入: nums = [3,3], target = 6
输出: [0,1]

解决方法

暴力循环法

第一次根据题目就是很简单,把数组中的所有数、两两组合在一起,并计算它们的和,如果计算的和是等于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];
}
  • 复杂度分析

通过代码得知,暴力循环法是由两个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];
}
  • 复杂度分析

通过代码得知,两遍哈希表是由两个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];
}
  • 复杂度分析

我们只遍历了包含有N个元素的列表一次。在表中进行的每次查找只花费O(1)的时间。其实这个过程中,我们也借鉴了动态规划的思想、把子问题解保存起来,后面用到就直接查询。所以一遍哈希表的时间复杂度是O(n)

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

©著作权归作者所有,如需转载,请注明出处,否则将追究法律责任
已于2022-1-19 10:35:52修改
1
收藏 1
回复
举报
回复
添加资源
添加资源将有机会获得更多曝光,你也可以直接关联已上传资源 去关联
    相关推荐