数据结构与算法学习

                                 数据结构与算法学习

一 复杂度
1.1 时间复杂度：算法执行效率
算法的执行时间与算法的输入值之间的关系
执行多少次

def test():
    total=0   #这一段所用时间a
    for i in range(num):
       total+=i           #这一段所用时间b
    return total   #这一段所用时间c

a+10b+c 这个受num的影响，当num较大时，忽略a,c;时间复杂度n b，，b相当于系数，O(N)
计算时间复杂度时，看程序是否有while for 循环。如果没有，一般为O(1)
1.2 一般的时间复杂度案例：
O(1) 表示算法执行时间与num没有关系
O(n)
O(log n)

def  f(num):
   i=1
   while (i<num)   
      i=i*2      
   return i

解释：num为N个，每次执行时间为a .执行次数为x,2^x=N,故x=log N. alog N,忽略系数a,得log N。

O(n log n)

O( n^2)

O(m+n)


时间复杂度排序：
O(n) < O(log n) < O(n) < O(n log n) <O( n^2)
< O( 2^n)< O(n!)
一般优化算法时，可以从降低时间复杂度角度分析。

2 .1空间复杂度：
空间复杂度：算法存储空间与输入值之间的关系。
声明的变量会占空间。
会占多少块空间

O(1 ) O(N )
2.2 常用空间复杂度
O(1) O(n) O( n^2)
二 数据结构1—数组
1 数组访问、数组搜索、插入数组、删除数组

数组是一个 适合读、不适合写的数据结构。
2 python数组常用操作
a.append() #添加元素【尾部】
a[2]
for index,element in enumerate(a):#即返回索引、值
#查找数组a某个元素的索引
a.index(2)

数组排序的时间复杂度O（N log N）

三 数据结构2–链表
3.1 数组：数值存在 连续 的内存空间…
不连续的内存空间存储，故提供了一种新的数据结构—链表

3.2 比较一个数据结构的好与坏，关键在于访问、搜索、插入、删除元素时的时间复杂度 O(N) O(N) O(1) O(1)
在链表中访问元素
单端链表
故写的块，读的慢不适合读，适合写
链表的每个节点里有两个属性：val,next
链表的python常用操作：
常用包deque
创建链表 linkedlist=deque()
添加元素linkedlist.append(1)#在末尾添加
linkedlist.insert(2,99)#在指定位置添加元素,第一个参数：索引的位置；第二个参数：元素值
访问元素 linkedlist[2]
查找元素linkedlist.index(99)99这个值对应的索引
更新元素 linkedlist[2]=88
删除元素linkedlist.remove(6)#参数为数值，不是索引
先遍历找到这个数，–O(N) ；在删除—O(1)

链表长度 len(linkedlist)

3.3 链表练习题：
203移除链表元素，
206反转链表

首先，关于单链表中的环，一般涉及到一下问题：

1.给一个单链表，判断其中是否有环的存在； 力扣141
最容易想到的方法是遍历所有节点，每次遍历到一个节点时，判断该节点此前是否被访问过。
可以使用哈希表来存储所有已经访问过的节点。每次我们到达一个节点，如果该节点已经存在于哈希表中，则说明该链表是环形链表，否则就将该节点加入哈希表中

```python
 class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        if head==None or head.next==None:
            return False
        #采用快慢指针进行
        slow=head
        fast=head.next
        while slow!=fast:
            if fast==None or fast.next==None:
                return False
            slow=slow.next
            fast=fast.next.next
        return True

2.如果存在环，找出环的入口点；力扣142
解析：
（一）设链表中环外部分的长度为 a。slow 指针进入环后，又走了 b的距离与fast 相遇。此时，fast 指针已经走完了环的 n 圈，因此它走过的总距离为 a+n(b+c)+b=a+(n+1)b+nca+n(b+c)+b=a+(n+1)b+nc
（二）任意时刻，fast 指针走过的距离都为slow 指针的 22 倍。因此，我们有
a+(n+1)b+nc=2(a+b) \implies a=c+(n-1)(b+c)
a+(n+1)b+nc=2(a+b)⟹a=c+(n−1)(b+c)
（三）从相遇点到入环点的距离加上 n-1 圈的环长，恰好等于从链表头部到入环点的距离

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        #链表存在环，找出环的入口点
        #先判断是否存在环
        if head == None or head.next==None: 
            return None
    
        slow = head
        fast = head
        #循环条件里的终止条件、条件判断很重要
        while fast!=None:
            slow = slow.next
            if fast.next != None:
                fast=fast.next.next
            else:
                return None
            if fast==slow:
                ptr = head
                while ptr!=slow:
                    ptr = ptr.next
                    slow = slow.next
                return ptr;
        return None

3.如果存在环，求出环上节点的个数；

4.如果存在环，求出链表的长度；

5.如果存在环，求出环上距离任意一个节点最远的点（对面节点）；

6.（扩展）如何判断两个无环链表是否相交；
7.（扩展）如果相交，求出第一个相交的节点； 力扣1925、160

利用快慢指针。如果有相交，则说明从相交部分开始后半部分相同；据此，得到不同链表的长度，并利用快慢指针将链表的head对其，同时移动比较。
class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        #依旧采用快慢指针思路
        #计算各个链表的长度
        a=headA
        count1=0
        while a!=None:
            count1=count1+1
            a=a.next 
        b=headB
        count2=0
        while b!=None:
            count2=count2+1
            b=b.next
        a=headA 
        b=headB   
        if count1>=count2:
            for i in range(count1-count2): 
                a=a.next   
        if count1<count2:
            for i in range(count2-count1): 
                b=b.next 
        #循环条件比较重要
        while a!=None and b!=None:
            if a==b:
                return a
                break
            a=a.next
            b=b.next
        return None

原文链接：https://blog.csdn.net/doufei_ccst/article/details/10578315

3.4 python实现链表数据结构
[python-链表](https://zhuanlan.zhihu.com/p/60057180)


四 数据结构3---队列Queue
1 特点：先入先出
2 单端队列：只有一个口可以进，一个口可以出
   双端队列

3 研究一个数据结构的特点
3.1 访问access  o(n)
3.2 搜索search  o(n)
3.3 插入insert    o(1)
3.4 删除remove o(1)

4 队列常用操作
我们都知道queue是队列，deque也是队列，不过稍稍特殊一些，是双端队列。对于queue来说，只允许在队尾插入元素，在队首弹出元素。而deque既然称为双端队列，那么说明它的队首和队尾都支持元素的插入和弹出。相比于普通的队列，要更加灵活一些。
[python的库collections的deque操作详解](https://zhuanlan.zhihu.com/p/110476502)
4.1   创建队列 python的内置函数
```python
from collections import deque
queue = deque()

添加元素 queue.append(1) ;queue.append(2) ;queue.append(3)
queue为 [1,2,3]
获取即将出队的元素 a=queue[0]
删除即将出队的元素 b=queue.popleft() b为 [2，3]
判断队列是否为空
队列长度 len(queue)
遍历队列（边删除边遍历队列操作）

while len(queue)!=0:
      temp=queue.pop
      queue.popleft()
      print (temp)

5 练习题
933 最近的请求次数
最近的请求次数
在构造函数中，self的使用
错误代码示范

from collections import deque
class RecentCounter:
    #构造函数：定义队列
    def __init__(self):
        Q=deque()

    def ping(self, t: int) -> int:
       Q.append(t)
        while (len(Q)>0 and Q[0]<t-3000):
            Q.popleft()
        return len(Q)

正确代码

from collections import deque
class RecentCounter:
    #构造函数：定义队列
    def __init__(self):
        self.Q=deque()

    def ping(self, t: int) -> int:
        self.Q.append(t)
        while (len(self.Q)>0 and self.Q[0]<t-3000):
            self.Q.popleft()
        return len(self.Q)

239 滑动窗口的最大值

五 数据结构4—栈
栈：先进后出
1 研究一个数据结构的特点
1.1 访问access o(1) 仅仅访问栈顶元素
1.2 搜索search o(n)
1.3 插入insert o(1)
1.4 删除remove o(1) 仅仅删除栈顶元素

2 栈常用操作

创建栈 python的内置函数

stack=[] or  stack=list() #    **使用列表构造栈数据结构**

添加元素 stack.append(1) ; stack.append(2) ; stack.append(3)
stack为 [1,2,3]
获取栈顶元素 a= stack[-1] #从后往前读
删除栈顶元素 b=stack.pop() b为 3 stack为[1,2]
判断栈是否为空 len(stack)==0
栈长度 len(stack)
遍历栈（边删除边遍历栈操作）

while len(stack)>0:
      temp=stack.pop() 
      print (temp)

3 练习题
充分利用到 栈后进先出的特点
20 有效的括号

class Solution:
    def isValid(self, s: str) -> bool:
        if len(s)==0:
            return 'True'
        else:
            #初始化一个栈
            a=stack()
            for c in s:
                if c=='(' or c=='[' or c=='{':
                    a.append(c)
                else:
                    if len(a)==0:
                        return 'False'
                    else:
                        #获取栈顶元素
                        temp=a.pop()
                        if c==')':
                            if temp!='(':
                                return 'False'
                        if c==']':
                            if temp!='[':
                                return 'False'
                        if c=='}':
                            if temp!='{':
                                return 'False'
            if len(a)==0:
                return 'True'
            else:
                return 'False'

496 下一个更大的元素

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        res=[]
        a=list()
        for i in nums2:
            a.append(i)
        for i in nums1:
            temp=list()
            isFound=False
            max_value=-1
            while (len(a)!=0 and isFound!= True):
                top=a.pop()
                if top>i:
                    max_value=top
                if top==i:
                    isFound=True
                temp.append(top)        
            res.append(max_value)
            while len(temp)!=0:
                a.append(temp.pop())
        return res

六 数据结构5—哈希表Hash Table[散列表]
简单来说，通过键：值来存放 学号：姓名，如果查找某个学号对应的姓名，则需要遍历；
于是，设计一种方法：将键 转化为索引，通过索引直接查找姓名。
python中—字典就是一种哈希表。
key—哈希函数—内存地址—key/vaue对应的内存地址
哈希碰撞：2个不同的key通过同一个哈希函数得到相同的内存地址。

1 研究一个数据结构的特点
1.1 访问access 没有
1.2 搜索search o(1) 对key搜索
1.3 插入insert o(1)
1.4 删除remove o(1)

2 哈希表常用操作

2.1 创建哈希表 python的内置函数

#第一种：直接用数组创建哈希表，索引当作哈希表的key
hashTable=[‘’]*4   #表示哈希表有四个元素,默认值为空字符串
#第二种：用字典创建哈希表
maping={}    或者mapping=dict()

2.2 添加元素

#第一种：在用数组创建的哈希表里添加元素
hashTable=[‘’]*4   #表示哈希表有四个元素,默认值为空字符串
hashTable[1]='韩梅梅'
hashTable[2]=‘李华’
#第二种：用字典的创建的哈希表里添加元素
maping={}    或者mapping=dict()
maping[1]='韩梅梅'
maping[2]=‘李华’

修改元素
2.3 删除元素

#用字典的创建的哈希表 删除元素
maping.pop(1)

del mapinng[1]

2.4 获取key的值
直接访问key

2.5 检查key是否存在

#用字典的创建的哈希表 
3 in maping  #返回Ture或者False

2.6 哈希表的长度
哈希表是否有元素

#用字典的创建的哈希表 
len(maping)  #返回Ture或者False

3 练习题
217 存在重复元素
389 找不同

标记：217与389 第一次都是使用python的字典进行解决的；利用key:value形式进行统计个数

496 下一个最大元素

七 数据结构6—集合set
7.1 无序，不重复
作用：查看元素是否存在，是否重复

7.2 集合的类型：HashSet\LinklistSet\Tree Set
7.3 HashSet

s=set()  #创建集合
s.add()  #添加元素
s.remove(2) #移除元素
len(s)      #长度

7.4 练习题
217
705
八 数据结构7—树【具备父子关系】
节点
根节点【唯一 一个】
叶子节点【没有孩子的节点 为叶子节点】

高度、深度、层

7.1 二叉树：每个节点最多只能有俩个个孩子

满二叉树：除了叶子节点，每个节点都有 左右两个孩子；所有叶子节点在同一层上
完全二叉树： 从树的根节点，从上到下、从左到右依次填满节点形成的二叉树

（1）二叉树的遍历
从根节点开始遍历，用拆分思想理解
前序遍历：根节点—左子树—右子树
中序遍历：左子树—根节点—右子树
后序遍历：左子树—右子树—根节点

前序遍历：A-B-D-E-C-F-G
中序遍历：D-B-E-A-F-C-G
后序遍历：D-E-B-F-G-C-A

（2）树的常用操作
（3）练习题
144 二叉树前序遍历

94 二叉树中序遍历
145 二叉树后序遍历

九 数据结构8—堆Heap
一种二叉树的结构
完全二叉树
每个节点>= 或者 <=孩子节点

十 数据结构9—图【Graph】
树：类似于父子关系
图：类似于邻居关系
顶点、邻居顶点、度、
无向图
有向图：入度、出度
权重图—最短路径

十一 经典算法