1.0 数组：在连续的内存空间中储存一组相同类型的元素
链表：空间位置不连续
创建： list = []
添加： list.append(a) O(1)在末尾添加
list.insert（0，a） O(n)在中间的位置添加
访问： list[0] O(1)通过索引直接计算出内存空间，不需要遍历，所以是O(1)
更新： list[0] = 1 O(1)
删除： list.remove(a) O(n)需要遍历出这个元素 a
list.pop(0) O(n)重前找到0索引对应的元素，然后还要把后面的元素往前挪动一个单位，相当 于遍历一遍，所以是O(n)
list.pop（） O(1) 只用删除最后一个元素，所以不用遍历
遍历： for i in list: O(n)
for i, j in range(0, len(list)):
for i , j in enumerate(list):
查找： list.index(a) O(n) 其中a是元素，返回索引，所以要遍历
排序： list.sort() O(nlog(n))
list.sort(reverse=True)
长度： len(list) O(n)
练习
class Test_1:
def test(self, num):
count = 0
result = 0
for i in num:
if i == 1:
count += 1
else:
result = max(result, count)
count = 0
return max(result, count)
test = Test_1
result = test.test(num = [1,1,1,0,0,0,0,1,1])
print(result)
2.0 链表：不连续的空间位置，但是用指针联系起来，数组是连续的内存空间
单端链表：只能用一个方向的指针
双端链表：可以两个方向的指针
链表主要是 读少写多
创建链表：list = deque() 其实就是队列
添加元素: list.append(a) O(1)
list.insert(0, a) O(n)
访问元素： list[0] O(n)
搜索元素： list.index(a) O(n) 找到元素a的索引，并且返回
更新元素： list[a] = b O(n) 找到索引，并且赋值
删除元素： list.remove(a) O(n)
del list[0] 删除指定索引的元素
链表长度： len（list） O(1) 每次会有一个变量记录传进链表的元素，最后会返回这个变量的值
3.0 队列： 排队，先到先得，一端进一端出
单端队列：一口进，一口出，
双端队列：左右两个口都能进，左右两个口都能出
搜索，访问只能重头到尾，插入是顺序的，末尾端插入的，删除只能删除第一个元素
创建队列： list = deque()
添加： list.append(a) O(1)
获取： list[0] O(1) 获取即将要出队的元素
删除： list.popleft（） O(1) 删除即将要离队的元素, 还会返还给你删除的元素
判断队列为空： len（list） == 0 O(1)
队列长度： len() O(1)
遍历队列： while len（list） ！= 0： O(n)
list_2 = list.popleft()
print(list_2)
4.0 栈： 先进后出，例子水杯，浏览器的后退功能，求导法则
创建： stack = []
添加： stack.append(a) O(1)
查看栈顶，即将出栈的： stack[-1] O(1)
删除栈顶，即将出栈的： stack.pop() O(1) 会保存删除的元素，没有遍历，所以是O(1)
栈的长度： len（stack） O(1)
栈是否为空： len（stack）== 0 O(1)
遍历栈，边删除栈顶元素，边遍历 ： while len（stack）> 0: O(1)
result = stack.pop()
print(result)
5.0 哈希表： 散列表，键值对，通过 key 得到 value
哈希碰撞：2个不同的key通过同一个哈希函数得到相同的内存地址
创建： mapping = {} 也可以用数组创建哈希表，通过索引来作为key
添加： mapping[0] = 'a' O(1)
删除： mapping[0] = '' O(1)
mapping.pop(0)
del mapping[0]
修改： mapping[0] = 'b' O(1)
获取： mapping[0] O(1)
检查key是否存在： 0 in mapping O(1) 返回的是TRUE还是FALSE
哈希长度： len(mappig) O(1) 返回是否为0
哈希是否有元素： len（mapping） == 0 O(1)
6.0 集合数据结构：无顺序，不重复，
元素的顺序不代表插入的顺序。和数组不同
创建： list = set()
添加： list.add(a) O(1) 没有索引，无顺序，无重合
查询： a in list: O(1) 在数T 没在是F
删除： list.remove(a) O(1)
长度： len(list) O(1) 有个变量在计算，所以不用遍历
7.0 树的主句结构： 描述的是父子关系，
8.0 堆：是一种二叉树的结构，完全二叉树数是堆，
创建
添加：
获取：
删除：
长度：
堆的遍历：
