LeetCode——两数之和

一.个人探索

二.网上优秀编程

三.程序进一步扩展优化功能

一.个人探索

1.暴力解法

答题思路：两个循环来遍历列表中的所有组合可能来获取答案值。
优点：简单易懂，比较容易想到的一种嵌套循环进行遍历的思想。
缺点：使用嵌套循环遍历整个数据，耗费时间多，空间多，程序的运行状况也是不太稳定的。
程序况如下：

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]

程序的运行结果也是很不稳定，大致徘徊在5476-7200ms之间

2.列表元素in方法

答题思路：减少未知量的方法来进行编程，首先我们已经知道target的值了，再设其中一个未知量的循环赋值，就可以判断另外一个未知量存在与否以及位置情况。
优点：简化程序运行的复杂度，大大提高了程序运行的速度。
缺点：程序编写较为复杂，一些细节需要格外注意。

程序况如下：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            a=target-nums[i]
            if (nums.count(a)==1)&(a==nums[i]): #1
                continue
            else :
                if a in nums :
                    j=nums.index(a,i+1) #2
                    return [i,j]
                

程序细节解析：
1）排除同一个数两次相加的可能
2）‘i+1’的含义是从i+1开始遍历寻找，从而避免了1）的再次发生
这个程序运行情况也是不太稳定，但速度效率都是在挺快的一个范围内

二.网上优秀编程

1.列表元素in方法的加强版

解题思路是在方法一的基础上，优化解法。想着，num2 的查找并不需要每次从 nums 查找一遍，只需要从 num1 位置之前或之后查找即可。但为了方便 index 这里选择从 num1 位置之前查找：

def twoSum(nums, target):
    lens = len(nums)
    j=-1
    for i in range(1,lens):
        temp = nums[:i]
        if (target - nums[i]) in temp:
            j = temp.index(target - nums[i])
            break
    if j>=0:
        return [j,i]

作者：lao-la-rou-yue-jiao-yue-xiang
链接：https://leetcode-cn.com/problems/two-sum/solution/xiao-bai-pythonji-chong-jie-fa-by-lao-la-rou-yue-j/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2.用字典模拟哈希求解

def twoSum(nums, target):
    hashmap={}
    for ind,num in enumerate(nums):
        hashmap[num] = ind
    for i,num in enumerate(nums):
        j = hashmap.get(target - num)
        if j is not None and i!=j:
            return [i,j]

作者：lao-la-rou-yue-jiao-yue-xiang
链接：https://leetcode-cn.com/problems/two-sum/solution/xiao-bai-pythonji-chong-jie-fa-by-lao-la-rou-yue-j/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

通过字典的方法，查找效率快很多，执行速度大幅缩短，共 88ms。

三.程序进一步扩展优化功能

我们先在程序能做的就是在给定一组数中找出来一对符合情况的数组，但是我们也可以设置一个程序来找出所有满足的数组对，且不会重复使用元素，我设置了有关的两个程序，不过在提交时因为用时过长而被pass掉了。

1.延续嵌套循环的方法的优化

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

2.列表成员in优化方法

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