LeetCode_1. 两数之和

1|0写在前面

难度：简单
原文链接：https://leetcode-cn.com/problems/two-sum/

题目

 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
 
 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
 
  
 
 示例:
 
 给定 nums = [2, 7, 11, 15], target = 9
 
 因为 nums[0] + nums[1] = 2 + 7 = 9
 所以返回 [0, 1]
 
 来源：力扣（LeetCode）
 链接：https://leetcode-cn.com/problems/two-sum
 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2|0我的思路

 1. 遍历列表，因为返回的是元素的索引就可以通过enumerate来记录
 2. 找到第一个元素，就去找这个元素与目标的差，如果在（余下的列表中）就返回2个元素的索引
 3. 依次循环做到最后第二个即可（但其实这个无需你处理）
 
 但是要注意几点
 1. 这个数不能用两遍，意味着只能在排除了当前数，（往后面）余下的列表中去找
 2. 返回的是2的数的索引，还是在余下的表中找出来的索引，但要加上自己之前的索引信息
 3. 默认是一定是能找到的，不用考虑找不到的情况

3|0我的代码

 class Solution:
     def twoSum(self, nums: List[int], target: int) -> List[int]:
         for i,v in enumerate(nums): #思路1.
             if target-v in nums[i+1:]: #思路2.
                 return [i,nums[i+1:].index(target-v)+i+1] #注意2.

分析

 由于主要用的是list，耗时和内存比较大，可以考虑用字典

4|0参考代码：用字典的思路1

 1. 将nums中的索引和值构造成一个字典
 2. 遍历列表，如果target-v的差值在字典中，且索引号不同就返回
 
 注意点：
 1. 为何是索引号不同就返回呢，如果索引号相同的话，就是同一个数，那对于偶数target，如果target/2在里面只有一个就有问题了。
 2. 由于要对索引号进行比较，一般用key来取value，那么我们应该把nums中的index作为value，列表中元素的值是key
 3. 基于2，列表中的值做key的话，可能会重复，导致后面的覆盖前面的，但是我们要明白，如果重复的值是结果的话，我们要得到的就是2个数据的索引，第一个值应该在nums中，第二个值在构造的字典中，是没有问题的。

 class Solution:
     def twoSum(self, nums: list, target: int) -> list:
         dict_nums = { v:i for i,v in enumerate(nums)}
         for i,v in enumerate(nums):
             if target-v in dict_nums and dict_nums[target-v]!=i:
                 return [i,dict_nums[target-v]]

5|0参考代码：用字典的思路2

 字典其实可以不先构造好。
 可以遍历列表，如果当前数与target的差在字典中，就返回当前值的索引和字典中已有数据对应的value，否则就放入字典中待用。

 class Solution:
     def twoSum(self, nums: list, target: int) -> list:
         dict_nums ={}
         for i,v in enumerate(nums):
             if target-v in dict_nums:
                 return [dict_nums[target-v],i]
             else:
                 dict_nums[v]=i

最佳内存分配

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            for j in range(i+1,len(nums)):
                if nums[i]+nums[j]==target:
                    return [i,j]

分析

看了下内存最好的处理方案，两次循环，但时间消耗应该是大的。

官方解释

暴力法（最佳内存分配）

时间复杂度：O(n^2)
对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费 O(n) 的时间。因此时间复杂度为 O(n^2)
空间复杂度：O(1)

用字典的思路1

时间复杂度：O(n)
我们把包含有 n 个元素的列表遍历两次。由于哈希表将查找时间缩短到 O(1) ，所以时间复杂度为 O(n)

空间复杂度：O(n)
所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 n 个元素。

用字典的思路2

时间复杂度：O(n)
我们只遍历了包含有 n 个元素的列表一次。在表中进行的每次查找只花费 O(1) 的时间。

空间复杂度：O(n)
所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 n 个元素

__EOF__

本文作者：博客已废弃
本文链接：https://www.cnblogs.com/wuxianfeng023/p/16598175.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！