必应壁纸供图

题目描述

两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/two-sum

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

思路分析

这是一道经典的数组算法题目。常规思路一般是使用双指针或者哈希表来解决。

双指针思路：

1.对数组进行排序，从小到大排列。

2.初始化两个指针left和right，分别指向数组的最左端和最右端。

3.循环移动指针，若left指向的数与right指向的数相加等于target，则找到了解，返回left和right对应的下标。

4.若left指向的数与right指向的数之和小于target，则需要增加left指向的数，使得和变大，继续循环。

5.若left指向的数与right指向的数之和大于target，则需要减小right指向的数，使得和变小，继续循环。

6.当left和right相遇时，则表明未找到解，返回空值。

哈希表思路：

1.使用一个哈希表来存储数组中的每个元素，元素作为键，下标作为值。

2.对于数组中的每个元素num[i]，在哈希表中查找是否存在target-num[i]，如果存在，则找到了解，返回num[i]和hashmap[target-num[i]]对应的下标。

3.若不存在，则将num[i]和i添加到哈希表中，继续循环。

4.当在整个数组中找不到解时，返回空值。

两种算法的时间复杂度都为O(n)，但是双指针算法的空间复杂度为O(1)，而哈希表算法的空间复杂度为O(n)。在空间限制不紧的情况下，哈希表算法更易于实现和理解。

第一种解法

class Solution(object):
    def twoSum(self, nums, target):
        # 遍历列表
        for i in range(len(nums)):
            # 计算需要找到的下一个目标数字
            res = target-nums[i]
                # 遍历剩下的元素，查找是否存在该数字
            if res in nums[i+1:]:
                # 若存在，返回答案。这里由于是两数之和，可采用.index()方法
                # 获得目标元素在nums[i+1:]这个子数组中的索引后，还需加上i+1才是该元素在nums中的索引
                return [i, nums[i+1:].index(res)+i+1]

时间复杂度是O(n^2)，因为有两层for循环，每次需要遍历剩下的元素去查找是否存在目标数字。空间复杂度为O(1)，因为只需要常量的额外空间，比如几个变量的存储空间。

第二种解法

class Solution:

    def twoSum(self, nums: List[int], target: int) -> List[int]:

        hashmap = {}

        for i, num in enumerate(nums):

            if target - num in hashmap:

                return [hashmap[target - num], i]

            hashmap[num] = i

时间复杂度为O(n)，因为只需要一遍遍历，每个数字只会被查找一次。空间复杂度为O(n)，因为需要使用一个字典存储数字及其在列表中对应的下标，最坏情况下需要存储数组中所有元素的信息。

对比分析

这两种算法的本质都是为了在数组中找到两个数的和为目标值，但是实现方式有所不同。

第一种算法是通过两层循环来遍历数组，每次需要在剩下的元素中查找是否存在目标数字，因此时间复杂度为O(n^2)，效率较低。

第二种算法则采用了哈希表来存储数字及其对应的下标，遍历一遍数组，时间复杂度为O(n)。并且哈希表查找的时间复杂度是常数级别的，因此效率更高。

因此，第二种算法相较于第一种具有更好的时间复杂度和效率。