LeetCode0001. 两数之和

一. 题目

1. 题目
   给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
   你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
2. 示例
   给定 nums = [2, 7, 11, 15], target = 9
   因为 nums[0] + nums[1] = 2 + 7 = 9
   所以返回 [0, 1]

二. 解法一: 暴力求解

1. 解题思路:
   1. 双重循环遍历列表中任意两个元素之和
   2. 如果之和等于 target
   3. 则将则两个元素的下标存放到列表中
   4. 然后此列表即可
2. 解题代码:

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

3. 分析
   时间复杂度: O(n^2)
   空间复杂度: O(1)

三. 解法二:

1. 解题思路

   1. 依次遍历列表中的每一个元素
   2. 再判断target - 当前元素的差值是否仍然在之后的列表中
   3. 如果存在, 则获取差值在之后列表中的下标
   4. 返回当前元素和差值下标

2. 解题代码

   def twoSum(self, nums: List[int], target: int) -> List[int]:
   	list1 = []
   	for i in range(len(nums)):
       	temp = target - nums[i]
       	# 判断差值是否在i之后的列表中存在
       	if temp in nums[i + 1:]:
       		# 获取i之后列表元素的下标
       		# 如果不加第二个参数, 当列表中存在两个相等的值时会出错
           	j = nums.index(temp, i + 1)
           	list1.append(i)
           	list1.append(j)
           	return list1
   	return list1
   

3. 分析
   时间复杂度: O(n)
   空间复杂度: O(1)

四. 方法三: 用字典模拟哈希求解(参考其他答案)

1. 解题思路

   1. 将列表中的元素和其对应的下标索引分别当做key, value存入map
   2. 如果列表中存在相同的value, 则只保留最后一个元素的下标
   3. 依次遍历列表中的下标index 和 value,
   4. map中获取key 为 target - value的值, 此结果就是原列表中的下标
   5. 返回当前index 和 获取到的下标, 即为最终结果

2. 解释
   为什么可以将列表中的元素和其对应的下标索引分别当做key, value存入map???
   如果list = [3, 2, 2, 4] target = 4

   1. 如果元列表中存在相同的元素, 则转化成map后, 只会保留最后一个元素的下标
      转换为map: {(2, 2), (3, 0), (4, 3)}
   2. 又因为题目中告诉了只有一种答案, 所以列表相同元素最多只有两个, 所以这里保存的是第二个元素的下标
   3. 如果结果是两个相同值的和, 则, 第一个元素就是当前的index, 第二个元素就是map获取的value
      当下标为0时, value = 3, map中key没有1
      当下标为1时, value = 2, map中key=2, 对应的value = 2
      所以最终结果就是[1, 2]

3. 解题代码

   def twoSum(self, nums: List[int], target: int) -> List[int]:
       hashmap = {}
       # 分别获取列表的下标和值
       for key, value in enumerate(nums):
       	# 将列表的value值作为map元素的key
       	# 将列表的下标作为map元素的value
       	# 如果列表中存在相同的value, 则只会保留最后一个下标
           hashmap[value] = key
       for i, v in enumerate(nums):
       	# 获取差值
           temp = target - v
           # 因为hashmap中将列表的元素值作为key, 所以这里通过key获取的value
           # 相当于列表中元素的下标
           j = hashmap.get(temp)
           if j is not None and i != j:
               return [i, j]
   

4. 分析
   此解的时间复杂度虽然任然是O(n), 但通过字典的方法，查找效率快很多，执行速度大幅缩短
   时间复杂度: O(n)
   空间复杂度: O(n)