01.[Python]Two-Sum 两数之和

一、问题描述：两数之和

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

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

示例 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]

提示：

• 2 <= nums.length <= 
• -109 <= nums[i] <= 
• -109 <= target <= 
• 只会存在一个有效答案

进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

二、实现方案

方案一：暴力求解：两次for 循环；

复杂度分析：

• 时间复杂度：O(n²)，两层循环遍历所有可能的组合。
• 空间复杂度：O(1)，仅使用常数空间。

def twoSum(nums, target):
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]
    return []

 方案二： 双指针法（需排序）

思路：

1. 将数组元素与其索引绑定，按值排序。
2. 使用双指针从排序后的数组两端向中间移动，寻找两数之和等于目标值。
3. 返回找到的两个数的原始索引。

def twoSum(nums, target):
    sorted_nums = sorted(enumerate(nums), key=lambda x: x[1])
    left, right = 0, len(sorted_nums) - 1
    while left < right:
        current_sum = sorted_nums[left][1] + sorted_nums[right][1]
        if current_sum == target:
            return [sorted_nums[left][0], sorted_nums[right][0]]
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return []

复杂度分析：

• 时间复杂度：O(n log n)，主要来自排序操作。
• 空间复杂度：O(n)，存储排序后的数组（包含索引）。

 方案三： 两次遍历哈希表法

思路：

1. 第一次遍历：将所有元素及其索引存入哈希表。
2. 第二次遍历：对每个元素，计算其补数（target - nums[i]），检查补数是否在哈希表中，并确保补数对应的索引不是当前元素自身的索引。

def twoSum(nums, target):
    hashmap = {}
    for i, num in enumerate(nums):
        hashmap[num] = i
    for i, num in enumerate(nums):
        complement = target - num
        if complement in hashmap and hashmap[complement] != i:
            return [i, hashmap[complement]]
    return []

复杂度分析：

• 时间复杂度：O(n)，两次独立遍历数组。
• 空间复杂度：O(n)，哈希表存储所有元素。

方案四：哈希表遍历法

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashtable = dict()
        for i, num in enumerate(nums):
            if target - num in hashtable:
                return [hashtable[target - num], i]
            else :
                hashtable[nums[i]] = i
        return []

复杂度分析：

• 时间复杂度：O(n)，一次独立遍历数组。
• 空间复杂度：O(n)，哈希表存储所有元素。

三、总结

• 哈希表一次遍历法：最优解，时间复杂度 O(n)，空间复杂度 O(n)，一次遍历即可完成。
• 暴力法：简单但效率低，仅适用于小数据量。
• 双指针法：适用于允许修改输入或需要利用有序性质的场景，但需额外空间存储索引。
• 两次遍历哈希表法：与一次遍历哈希表法类似，但需要两次遍历数组。