python(leetcode)-1.两数之和

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

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

示例:

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

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

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

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

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

 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( len(nums)):
                 if(nums[i]+nums[j]==target and i!=j):
                     result.append(i)
                     result.append(j)
                     break
         aset=set(result)        #利用set无重复性消除重复添加
         alist=list(aset)

         return alist

 if __name__=="__main__":
     s=Solution()
     nums=[3,2,4]
     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 result

if __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%

 class Solution:

     def twoSum(self,nums,target):
         """
         :param nums:
         :param target:
         :return:
         """
         sort=sorted(range(len(nums)),key=lambda x:nums[x])
         i=0
         j=len(nums)-1
         alist=[]
         while(nums[sort[i]]+nums[sort[j]]!=target):
             if(nums[sort[i]]+nums[sort[j]]>target):  #当最大的元素和最小的元素相加大于目标值
                 j-=1                                 #最大元素前移一个位置
             else:                                    #小于目标值时
                 i+=1                                 #最小元素后移一个位置
         alist.append(sort[i])
         alist.append(sort[j])
         return alist

 if __name__=="__main__":
     s=Solution()
     nums= [2, 1, 3, 8, 4]
     print(s.twoSum(nums, 6))

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

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

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

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

时间复杂度分析：

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

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

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

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

 class Solution:
     def twoSum(self,nums,target):
         """
         :param nums:
         :param target:
         :return:
         """
         dit={}
         for index,num in enumerate(nums): #遍历值和下标
             sub=target-num
             if(sub in dit):
                 return [dit[sub],index]   #返回字典中的下标和index
             dit[num]=index                #将num和index插入dit中
         return None
 if __name__=="__main__":
     s=Solution()
     nums= [2, 1, 3, 8, 4]
     print(s.twoSum(nums, 4))

解释下设计思想：

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

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

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