编程学习（一）两数之和

题目描述

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

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

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

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

初步尝试(两个for循环嵌套)

刚开始的想法是采用两个for循环嵌套采取下标的方式，一旦满足要求便将下标删除，依次遍历。
代码如下

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        index = [k for k in range(len(nums))] # 运行n次
        for i in index:                       # 运行n次
            for j in index[i+1:]:             # 运行n-i次
                if nums[i]+nums[j]==target:   
                    index.remove(i)
                    index.remove(j)
                    return [i,j]

则根据时间复杂度的运算规则可知T(n)=O(n^2)
在LeetCode的测试提交平台

6352ms运行时间很长

改进（去掉一个for循环）

这时，如果想要改进我们的代码的运行效率的话便可以考虑去掉一个for循环。

class Solution:
    def twoSum(self, nums, target):
        n = len(nums)
        for x in range(n):       # 运行n次
            a = target - nums[x] 
            if a in nums:        # 需要遍历n次
                if x!=nums.index(a):#当两个元素的下标不等的时候
                    return [x,nums.index(a)]

可能最坏的情况下时间复杂度为T(n)=O(n^2)（补充：python中list对象的存储结构采用的是线性表，因此其查询复杂度为O(n) 也就是 if a in nums 时间复杂度是O(n)）
LeetCode平台测试结果：

可以看出结果比之前要好很多

继续改进

创建字典形式，差值为 键，索引为值。

  def twoSum(self, nums, target): 
      d={}
      n = len(nums)
      for i in range(n):
          a = target - nums[i]
          if a in (d.keys()):            
              return [i,d[a]]
          else:
              d[nums[i]] = i

则可以看出其时间复杂度为O(n).
LeetCode的结果：

可以看出运行速度有了质的提升。

字典和列表的对比

那为什么用了字典结构会有如此大的提升呢？
那是和字典的实现原理有关系

哈希表（字典）和顺序表（列表）

字典

字典的实现过程用到了一个叫哈希表的数据结构。
哈希表（也叫散列表），根据关键值对(Key-value)而直接进行访问的数据结构。它通过把key和value映射到表中一个位置来访问记录，这种查询速度非常快，更新也快。而这个映射函数叫做哈希函数，存放值的数组叫做哈希表。 哈希函数的实现方式决定了哈希表的搜索效率。具体操作过程是：

数据添加： 把key通过哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里。
数据查询： 再次使用哈希函数将key转换为对应的数组下标，并定位到数组的位置获取value。
但是，对key进行hash的时候，不同的key可能hash出来的结果是一样的，尤其是数据量增多的时候，这个问题叫做哈希冲突。如果解决这种冲突情况呢？通常的做法有两种，一种是链接法，另一种是开放寻址法，Python选择后者。
想深入了解的可以参考这篇文章

列表

而python中的列表实际上采用的就是数据结构中的顺序表,而且是一种采用分离式技术实现的动态顺序表。 相关内容可参考这篇文章
因此列表有以下特点：

1. 元素有位置下标，以索引就可以直接取到元素 --> 连续的存储空间，以偏移量计算取得元素，不必遍历所有元素
2. 元素无论如何改变，表对象不变，也就是其id不变 --> 分离式结构，表头和元素内容分开储存，这样在更改list时，表对象始终是同一个，只是其指向的地址不同
3. 元素可以是任意类型 --> 既要要求是连续存储，又可以存储不同类型的数据，那么其用的就是元素外置的方式，存储的只是地址的引用
4. 可以任意添加新元素 --> 要能不断地添加新元素，其使用了动态扩充的策略
   从实现上来讲，在python中创建空ist时，会申请一个8个元素大小的内存区域。以后如果满 了，就扩容4倍，且当元素总数达到50000时，再扩容就改为2倍。

还有其他的方法暂时没有了解也想不出来，仍然需要努力。