刷题笔记

2021.03.06
1.字符串转列表：
list（str）
2.列表转字符串：
创建一个空字符串str = ’ '，用for循环把列表中的元素挨个取出来，加在空字符串后头。用+就可以。
“”.join(列表）双引号里面不要有空格！！！
3.列表的替换：
替换就是删除+插入。按照索引删除list.pop(index)。按照索引插入list.insert（index，“ xx”）。
按照值删除：list.remove(值)
4.取出字符串s的值可以直接for循环。for i in s：
5.数据类型：
（1）计算机的内存是连续的存储空间，一个字节8位有一块标识。cpu根据这个标识去内存中找数据。
（2）32位的机器，整型需要4字节；但是其他类型所占的空间不同，因此计算机怎么去取数据，取出来转换成什么样的，取决于定义了什么类型的数据。
（3）例如我要存一个list，那list中的数据都是整型，需要放在连续的存储单元。通过第一个元素的地址，就可以得到后面所有元素的地址，去取出对应的元素，就是顺序表。

6.线性表包括顺序表和链表
7.顺序表（list、tuple）
**（1）元素内置的顺序表：**数据元素本身连续存储，所占存储单元大小固定，元素下标是逻辑地址，根据逻辑地址和存储区的起始地址可以算出存储数据的实际物理地址。
**（2）元素外置的顺序表：**比如说list里面既有整型，又有字符串，所占的空间是不一样的，元素内置的顺序表必须是数据所占空间相同的，才能通过逻辑地址来算出物理地址，找到所有数据。但是他们的逻辑地址所占空间相同，因此在连续的存储单元中存的是逻辑地址，再由逻辑地址指向数值。

（3）操作：
插入：
尾端加入元素，直接插，时间复杂度0（1）
非保序，直接把序号上的那个挪到最后一个，再插，时间复杂度o（2），也就是o（1）
保序元素插入，需要一个一个往后挪，空出位置再插。最坏的情况时间复杂度o（n）

删除：
表尾还是o（1）
非保序o(1)
保序删除o（n）

list.append() o(1) 表尾插入
list.insert(i,item) o(n)
list.pop() o(1)
list.pop(i) o(n)

8.链表
顺序表需要预先知道数据大小申请连续的存储空间，扩充时需要数据搬迁，不够灵活。所以出现了链表。数据区保存数据，链接区保存下一节点的地址。
（1）单向链表

1）基础知识
尾节点指向空。第一个节点是头结点。
python中，**两个变量互换赋值可以a=10;b=20;a,b = b,a。**原因是a=10相当于a这个数据区域放的是10所在的地址。单纯改变指向。一切皆对象，定义一个函数def f():,这个函数也是对象，可以用a=f()，只是a存放函数的地址指向这个函数。a可以随便等于类等于函数等于数值。所以a并不需要定义数据类型。在等号右边，a=b，指的是，a指向了b所指的区域的数据；而在等号的左边，就是a

2）结点实现：
next表示下一节点的位置，用等号，相当于把第一个结点的next指向了node2。**等号改变了指向！重要！**虽然python中没有链接的概念，但是变量的本质就是这样的。注意等号右边和等号左边的区别。

因此只需要定义一个区域，去指向下一个节点。

需要两个类，一个链表类，一个节点类。构造链表，之后一个头节点指向空，构造节点数据区存数据，链接区指向空。两个连起来让头节点指向构造的节点即可。

3）与顺序表优缺点：
顺序表在访问元素的时候可以通过下标直接访问，时间复杂度低，但是内存要连续不灵活。
链表空间开销大，因为不仅要存数据，还要存地址，所以占内存。但是内存又是分散的，能够解决顺序表内存必须连续不灵活的问题。此外，存取元素时间复杂度都是o（n）

（2）单向循环链表

p指向的单独的那个块是表节点，放的其他信息。
单向循环链表的删除操作要注意：
同样需要两个游标来记录要删节点的前一个位置和后一个位置。
在删除头节点的时候，尾节点指向要改成新的头节点，因此要新建游标去找尾节点在哪。
删除尾节点的时候要注意到如果只有这一个节点，pre游标就指向None了，会不合法。

（3）双向链表

后继节点和前驱节点。

9.栈（LIFO，Last In First Out）
（1）像个瓶子。保证任何时候访问、删除元素都是最后存入的，确定了一种默认的访问方式。只要是这么种操作特点，就是栈。不用管物理实现（可以用顺序表、链表实现）。
（2）stack（）创建空栈；push（ ）入栈；pop（ ）出栈；peek（）返回栈顶元素；
10.队列（FIFO）
可以用很多数据结构来实现。队头队尾。
11.双端队列
相当于是两个栈的底部合起来了。可以从队头push和pop，也可以从队尾push和pop。同样可以用list实现。

12.# coding:utf-8 固定编码格式，打中文不报错
13.self关键字是干啥的：
类实例化多个对象的时候，确保访问自己对象的数据。每个对象的self都指向自己空间的数据。比如一个类里面定义了两个函数。每个函数里都有len，一个等于10，一个等于100；确保每个函数只访问到自己的len，就要加self.len。
self就是个指针，类似于c++里的this指针。
self只是python里面推荐的关键字，把它改成其他关键字也可以，比如abc。

14.init()与__new__()的区别
init：构造函数，创建类的时候开辟空间初始化对象。

15.元组和列表的区别
（1）存储方面，列表占得空间大于元组
list存在预分配的情况，在创建一个空列表的时候，会直接分配40字节。另外还需要一个记录列表空间是否占满的额外空间。
元组一旦创建，直接在内存中写死。
（2）性能，元组强
元组是静态的，python对其做了优化。比如让t=（1，2，3），此时相当于对这个元组做了引用。让t不等于这个元组的时候，小的元组会进入缓存池，在下一次要使用的时候不需要分配空间之后的操作，直接载入即可。
list是动态的，没办法利用缓存机制增强性能。
元组可以作为字典的key
（3）增删改效率
list可以直接进行元素拼接，指针指向不变
元组需要申请内存空间，将元组里面的元素复制过去，再append
效率低只是因为需要重新开辟内存空间，不是因为数据结构，底层他俩用的都是数组array
16.return返回的时候，先把后面的数算出来再返回。如果return后是一个等式，返回布尔值。
**17.**空列表、空字符串、空字典、空元组逻辑值都是假的，可以直接逻辑判断。

18.树
（1）术语

（2）种类

完全二叉树：除了最底下那层，上面的都有2个子节点

满二叉树：

排序二叉树：有某种顺序。例如节点左边都小于节点，右边都大于节点。

（3）存储与表示



2021.03.08
1.TCP的三次握手四次挥手
TCP报文格式：

32位序号（seq）是随机生成的，代表每个报文的序号，比如说发来的请求seq是10000，从10000开始的，如果有一个发来的是900，明显不合法，直接丢掉；32位确认序号（ack）也是随机生成的，对上一条发送的信息进行确认；ACK为确认标志位，0或1；SYN为发起一个新的链接，0或1；FIN为结束一个链接，0或1.

TCP/IP 协议是传输层的一个面向连接的安全可靠的一个传输协议，三次握手的机制是为了保证能建立一个安全可靠的连接，那么第一次握手是由客户端发起，客户端会向服务端发送一个报文，在报文里面：SYN标志位置为1，表示发起新的连接。当服务端收到这个报文之后就知道客户端要和我建立一个新的连接，于是服务端就向客户端发送一个确认消息包，在这个消息包里面：ack标志位置为1，表示确认客户端发起的第一次连接请求。以上两次握手之后，对于客户端而言：已经明确了我既能给服务端成功发消息，也能成功收到服务端的响应。但是对于服务端而言：两次握手是不够的，因为到目前为止，服务端只知道一件事，客户端发给我的消息我能收到，但是我响应给客户端的消息，客户端能不能收到我是不知道的。所以，还需要进行第三次握手，第三次握手就是当客户端收到服务端发送的确认响应报文之后，还要继续去给服务端进行回应，也是一个ack标志位置1的确认消息。通过以上三次连接，不管是客户端还是服务端，都知道我既能给对方发送消息，也能收到对方的响应。那么，这个连接就被安全的建了。

四次挥手机制也是由客户端去发起，客户端会发送一个报文，在报文里面FIN位标志位置一，当服务端收到这个报文之后，我就知道了客户端想要和我断开连接，但是此时服务端不一定能做好准备，因为当客户端发起断开连接的这个消息的时候，对于服务端而言，他和还有可能有未发送完的消息，他还要继续发送，所以呢，此时对于服务端而言，我只能进行一个消息确认，就是我先告诉服务端，我知道你要给我断开连接了，但是我这里边还可能没有做好准备，你需要等我一下，等会儿我会告诉你，于是呢，发完这个消息确认包之后，可能稍过片刻它就会继续发送一个断开连接的一个报文啊，也是一个FIN位置1的报文也是由服务端发给客户端的啊，这个报文表示服务端已经做好了断开连接的准备，那么当这个报文发给客户端的时候，客户端同样要给服务端继续发送一个消息确认的报文一共有四次，那么，通过这四次的相互沟通和连接，我就知道了，不管是服务端还是客户端都已经做好了断开连接的准备，于是连接就可以被断开啊，这是我对三次握手和四次挥手的一个理解。

2021.03.10
1.排序算法的稳定性
比如说排一个元组，（3,3），（3,1）。第一位相同。稳定的排序算法排序之后不会改变原有次序，不稳定的可能会排成（3,1）（3,3）。
2.冒泡排序（都以从小到大排）

实现两个循环：
（1）班长每从头到尾（0~n-1-j）走一次，往上冒个泡，冒个最大值。
（2）一共走j次。
时间复杂度：最优o（n），遍历了一次没交换；最坏o（n2）
稳定性：稳定

2.range(开始=0, 5, 步长=1) : 0 1 2 3 4

3.选择排序
可以这么想：认为整个序列是分为两部分的，前面是有序的序列，后面是无序的，从后面选择最小值往前面的有序序列中放。
要解决的就是怎么去找这个最小值。开始默认0位置的元素是最小值min，接着往后遍历，遇到一个比0位置小的，将min换成这个更小的值得位置，知道遍历整个列表。然后交换这俩元素。
最坏最优时间复杂度都是o（n2）。找最小没办法优化。
不稳定。如果是要排一个升序的序列，在找到第一个最大的a，放在序列最后。找到第二个最大的a放在倒数第二位。所以第一个a和第二个a的顺序换了。

2021.03.14
1.插入排序
和选择排序一样，可以把序列看成两部分，第一部分是有序的，第二部分是无序的。开始的时候第一部分只有0位置的数，1位置的跟他比较，小于它就往前插入。插完之后相当于有序的序列多了一个数。接着2位置的依次和1位置的、0位置的比较，小于就换，不小就待着。
在写代码的时候，内层循环比较之后，如果不需要换位置，循环break。那在整个序列是一个有序序列的时候，时间复杂度在内层循环是没有的，压根不执行，直接break。
**时间复杂度：**最优o（n）；最坏o（n2）
**稳定性：**稳定。插入的时候，相等的情况不判定，直接往后插，不会换位置。

2.希尔排序（插入排序的改进版）
就是给一个序列分组（但不是真正的分开，只是看作几组），对每一组进行插入排序，这个分的组越来越多（gap越来越小），直到最后gap=1，就排完了。
**时间复杂度：**最优根据数学来的；最坏就是插入排序。
**稳定性：**不稳定。因为是分组进行插入的，很有可能出现一个数在第一个组中需要交换，而另外一个同样的数在另外一组中不需要交换，可能两个相同的数就会换了位置。

3.快速排序
需要两个游标，一个low一个high，还需要一个存储中间值的。先把第一个元素作为mid_val，比他大的都放右边，比他小的都放左边，相当于直接找到了midval的位置。再把左边的序列和右边的序列分别进行快排。这里可以使用递归。（使用递归的时候要注意，是在原列表上进行操作，而不是去把左边的列表和右边的列表再建个新的，所以写快排的时候要传入参数：列表的开始位置和结束位置，方便递归调用）。
时间复杂度：
最优情况：对整个序列取了多少个对半拆分。经过多少个2，把序列分到底。o（nlogn）
最坏情况：第一次分，左边一个元素，右边一堆。第二次分还这样。o(n2)
**稳定性：**不稳定。