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

 看到这道题，不难理解，就是找出两个值的和等于特定值的下标。

笔者没有太多的想法，用python暴力法先实现一遍

上代码（未通过-超出时间限制）

1 class Solution: 2     def twoSum(self, nums, target): 3         """ 4         :type nums: List[int] 5         :type target: int 6         :rtype: List[int] 7         """ 8         result=[] 9         for i in range(len(nums)):10             for j in range( len(nums)):11                 if(nums[i]+nums[j]==target and i!=j):12                     result.append(i)13                     result.append(j)14                     break15         aset=set(result)        #利用set无重复性消除重复添加16         alist=list(aset)17 18         return alist19 20 if __name__=="__main__":21     s=Solution()22     nums=[3,2,4]23     print(s.twoSum(nums,6))

分析原因：代码两层for循环,时间复杂度为O(n^2),所以遇到数据量大的情况耗时较久。

优化：上代码（通过-6800ms）击败20%

class Solution:    def twoSum(self, nums, target):        """        :type nums: List[int]        :type target: int        :rtype: List[int]        """        result=[]        for i in range(len(nums)):            for j in range(i+1, len(nums)):   #第i个和第i个之后的数值进行求和对比                if(nums[i]+nums[j]==target ): #取消了i和j的对比                    result.append(i)                    result.append(j)                    break        return resultif __name__=="__main__":    s=Solution()    nums=[3,2,4]    print(s.twoSum(nums,6))

解释一下：

       两层for循环每一个和其他元素进行求和的过程中会出现，相同的数操作两遍的情况（比如i为下标3的数，j为下标6的数）当i和j的值互换（i=6,j=3)又求和进行操作，所以第二层循环再第i+1个开始，避免重复操作。这样理论可以提高50%的效率。但是时间复杂度依旧为O(n^2)。所以比较耗时。

之后怎么也想不到更好的方法，

所以借鉴评论区的大佬代码（通过-48ms)击败89%

1 class Solution: 2  3     def twoSum(self,nums,target): 4         """ 5         :param nums: 6         :param target: 7         :return: 8         """ 9         sort=sorted(range(len(nums)),key=lambda x:nums[x])10         i=011         j=len(nums)-112         alist=[]13         while(nums[sort[i]]+nums[sort[j]]!=target):  14             if(nums[sort[i]]+nums[sort[j]]>target):  #当最大的元素和最小的元素相加大于目标值15                 j-=1                                 #最大元素前移一个位置16             else:                                    #小于目标值时17                 i+=1                                 #最小元素后移一个位置18         alist.append(sort[i])19         alist.append(sort[j])20         return alist21 22 if __name__=="__main__":23     s=Solution()24     nums= [2, 1, 3, 8, 4]25     print(s.twoSum(nums, 6))

说下设计思想：（首尾递归查找）

首先第一部的排序有点技巧性，因为我们需要排序后才能首位递进查找，但是又需要返回排序前的下标。

所以根据list的值排序并且保存的是list的下标。这样就可以找到排序前的下标。

后面的代码比较简单，当和大于target时，最后一个位置向前移，当和小于target时，第一个位置向后移，

时间复杂度分析：

sorted()的复杂度为O(nlogn)

while()的复杂度为O(n)

所以复杂度为O(nlogn)  比之前的O(n^2)快了很多

 

然后在介绍一个更快的方法 先上代码（通过44ms)超过99%

1 class Solution: 2     def twoSum(self,nums,target): 3         """ 4         :param nums: 5         :param target: 6         :return: 7         """ 8         dit={} 9         for index,num in enumerate(nums): #遍历值和下标10             sub=target-num                11             if(sub in dit):12                 return [dit[sub],index]   #返回字典中的下标和index13             dit[num]=index                #将num和index插入dit中14         return None15 if __name__=="__main__":16     s=Solution()17     nums= [2, 1, 3, 8, 4]18     print(s.twoSum(nums, 4))

解释下设计思想：

利用字典可以存放key和value。根据与target的差值查找是否出现在字典中，如果有则返回下标，无则将index和num放入字典中并且遍历下一个，直到结束。

该方法for循环N次 减法操作1次，字典查询是否存在最优情况下是1次，字典赋值语句1次

总的复杂度为O(n) 所以该方法特别快