leetcode刷题笔记之1（python语言）1 两数之和TwoSum

题目描述：

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

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

示例:

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

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

题解一--暴力穷举

对num1和num2分别进行循环，即两层循环，执行代码可以得出正确答案，但是提交后提示“超出时间限制”

    def twoSum(nums, target):
        res = []
        for i in range(len(nums)):
            for j in range(i+1,len(nums)):
                if nums[i] + nums[j] == target: # num1:nums[i],num2:nums[j]
                    res.append(i)
                    res.append(j)
        return res

题解二--暴力穷举变种，利用python列表切片

方法1：num2 = target - num1,在去掉已经用过的元素的列表中查找num2，主要在于如何返回num2的下标，num2的下标=去掉已经用过的元素的列表的下标+已经去掉元素的个数（i+1），index返回list中元素第一次匹配到的下标

【执行用时：996s，内存消耗：13.9M】

    def twoSum(nums, target):
        res = []
        for i in range(len(nums)-1):
            num2 = target - nums[i]
            if num2 in nums[i+1:len(nums)]:
                res.append(i)
                res.append(nums[i+1:len(nums)].index(num2) + i+1)
        return res

方法2：方法1是对第一个数for循环，在右边剩下数的列表中查找num2，求解num2的下标稍显麻烦；

num1 = target - num2，若对num2进行for循环，在左边剩下的数中查找num1，求解num1的下标，直接取下标即可

【执行用时：1028s，内存消耗：13.9M】

    def twoSum(nums, target):
        res = []
        for i in range(1,len(nums)):
            num1 = target - nums[i] # nums[i]为num2
            if num1 in nums[0:i]:
                res.append(nums[0:i].index(num1))
                res.append(i)
        return res

方法3：enumerate返回所有list中元素所有匹配到的下标list，如果i在下标list中取第二个下标，否则取第一个下标

【执行用时：924s，内存消耗：13.9M】

    def twoSum(nums, target):
        res = []
        for i in range(len(nums)-1):
            num2 = target - nums[i]
            if num2 in nums[i+1:len(nums)]:
                res.append(i)
                list_num2_index = [i for i,k in enumerate(nums) if k == num2]
                if i in list_num2_index:
                    res.append(list_num2_index[1])
                else:
                    res.append(list_num2_index[0])
        return res

题解三--哈希表

通过空间换取时间的方式，通过字典来模拟哈希查询的过程

方法4：两遍哈希，第一遍哈希通过字典记录num2的值和下标，省去了查找的时间

    def twoSum(self, nums: List[int], target: int) -> List[int]:
        dct = {}
        for i in range(len(nums)):
            dct[nums[i]] = i # 获取num2的值和下标，字典的key唯一，若出现重复值，覆盖成新的下标
        for j in range(len(nums)):
            num2 = target - nums[j]
            if num2 in dct and j!=dct[num2]:
                return [j, dct[num2]]

方法5.1：一遍哈希，通过字典记录num1的值和下标，可以省去方法4中第一层获取num2的值和下标的循环

    def twoSum(nums, target):
        dct = {}
        for i in range(len(nums)):
            num1 = target - nums[i] # nums[i]为num2
            if num1 in dct:
                return [dct[num1], i]
            dct[nums[i]] = i

方法 5.2：使用enumerate优化代码，下边给出方法5.1的优化代码

    def twoSum(nums, target):
        dct = {}
        for i, n in enumerate(nums):
            num1 = target - n # n为num2
            if num1 in dct:
                return [dct[num1], i]
            dct[n] = i

总结

在一个列表中找出两个数num1、num2，使得两个数的和为target，并返回两个数的下标

思路一：

直接正向穷举法，分别对num1和num2进行循环，直至找到满足要求的两个数（题解一）

思路二：

由num1 + num2 = target，有

num2 = target - num1，对num1进行循环，在剩下的右侧的列表中查找num2并返回num2的下标（题解二方法1和方法3）

num1 = target - num2，对num2进行循环，在剩下的左侧的列表中查找num1并返回num1的下标（题解二方法2）

思路三：

在思路二中，是在列表中查找num1和num2的下标，可以用哈希表记录数值和下标

num2 = target - num1（哈希表记录num2的值和索引，题解三方法4）

num1 = target - num2（哈希表记录num1的值和索引，题解三方法5.1和方法5.2）

时间复杂度和空间复杂度如下：

方法	时间复杂度	空间复杂度
暴力穷举	O（n^2）	O（1）
暴力穷举变种	O（n^2）	O（1）
两遍哈希	O（n）	O（n）
一遍哈希	O（n）	O（n）