数据结构考试复习

拼搏现实的明天。 2022-12-27 04:51 293阅读 0赞

# 数据结构简答题题型 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70]

## 一.匹配字符串 ##

1）计算串的next与nextval  
计算next值方法  
如表格类型

`方法1`  
求next值,常规方法1  
利用串匹配常规法代即可  
下标法类代

`方法2`：利用前缀匹配和后缀匹配相等值代

#（这里的前缀是不包括最后一个字符的子串，后缀是不包含第一个字符的子串）

如  
第三位：字符串是"bab"，前缀有b, ba；后缀有ab,b，前后缀相等的最长字符串为b，长度为1，所以第三位Next值为1

第四位：字符串"baba"，前缀有b, ba, bab；后缀有aba, ba, a，前后缀相等的最长字符串为ba，长度为2，所以第三位Next值为2–>如果值只为一个,即值直接加1  
如果最后得到的串大于等于2  
就代相互取值加一的方法代

##例如得到ba，是把ba变成-1,b(前面加上-1,结尾那个去掉)。第二步:把-1,b的值全部加上1，得到0,b+1就是最终的值-->
    即代出值为2

2）计算nextval值

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>1</th> 
   <th>2</th> 
   <th>3</th> 
   <th>4</th> 
   <th>5</th> 
   <th>6</th> 
   <th>7</th> 
   <th>8</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>例子</td> 
   <td>a</td> 
   <td>b</td> 
   <td>a</td> 
   <td>a</td> 
   <td>b</td> 
   <td>c</td> 
   <td>a</td> 
   <td>c</td> 
  </tr> 
  <tr> 
   <td>next</td> 
   <td>0</td> 
   <td>1</td> 
   <td>1</td> 
   <td>2</td> 
   <td>2</td> 
   <td>3</td> 
   <td>1</td> 
   <td>2</td> 
  </tr> 
  <tr> 
   <td>nextval</td> 
   <td>0</td> 
   <td>1</td> 
   <td>0</td> 
   <td>2</td> 
   <td>1</td> 
   <td>3</td> 
   <td>0</td> 
   <td>2</td> 
  </tr> 
 </tbody> 
</table>

总结下规律：第一位的nextval值肯定为0，第二位，观察第一位，相同为0，不同为1。剩下的求nextval：  
若当前值即例子中的值与当前next所对应的值不同，则直接为当前next值；若相同，则继续查找对应的next值，有不同的就把对应的next值给nextval（正如上面的第五位查找），否则为0。

如步骤分析

第一位-->直接赋值为0完事
    第二位-->b与第一位的a不同-->直接为1
    第三位-->next的值为1相同,继续查找,查找到同为a的情况,即发现第一位,next为0,不同-->即第三位的next值为0

代码原理

#include<bits/stdc++.h>
    using namespace std;
    #define maxn 255
    typedef struct
    { 
        char ch[maxn+1];
    } SString;
    void Init(SString &S)
    { 
        char str[maxn];
        cin>>str;
        S.ch[0] = strlen(str);//用第一个位置，存数组的长度
        for(int i=0;str[i];i++)
            S.ch[i+1] = str[i];
    }
    void get_nextval(SString &S1,int nextval[])
    { 
        int i=1,j=0;
        nextval[1] = 0;
        while(i<S1.ch[0])
        { 
            if(j==0||S1.ch[i]==S1.ch[j])
            { 
                i++;
                j++;
                if(S1.ch[i]!=S1.ch[j])nextval[i] = j;
                else
                    nextval[i] = nextval[j];
            }
            else
                j = nextval[j];
        }
        for(int k=1; k<=S1.ch[0]; k++)
            cout<<nextval[k]<<' ';
    }
    void get_next(SString &T,int next[])
    { 
        int i=1,j=0;
        next[1] =0;
        while(i<T.ch[0])
        { 
            if(j==0||(T.ch[i]==T.ch[j]))
            { 
                ++i;++j;
                next[i]=j;
            }
            else
                j = next[j];
        }
         for(int k=1;k<=T.ch[0];k++)
            cout<<next[k]<<' ';
    }
     
    int main()
    { 
        SString S1;
        Init(S1);
        int next[maxn];
        ///Get_next(S1,next);
        get_next(S1,next);
        cout<<endl;
        get_nextval(S1,next);
    }

3.)写出KMP算法匹配的全过程  
如即匹配到不一样的,即把这个内容作为新的起点,然后在代排序即可  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 1]

## 二.矩阵考法 ##

1.)稀疏矩阵与三元组表互换  
即代有值的进行i,j,v关系代即可  
现有一个稀疏矩阵，请给出它的三元组表。  
![在这里插入图片描述][20201208092938168.png]

三元组表即i代表行,j代表列,v代表的是值–>即利用行列对应的相互值代即可  
代表即可  
![在这里插入图片描述][20201208093001604.png]

2.)图的邻接矩阵<–>有向表,邻接表,深搜广搜转换类  
①直接给图进行代深搜和广搜  
深度搜索–>利用邻接代+存储顺序代排序出  
广度搜索–>利用按照层次遍历出–>思考下面的为何不可的原因  
[四种典型图排列方法][Link 1]  
②给邻接矩阵代深搜和广搜  
1.邻接矩阵转图

#有向图和娃娃向图判断方法
    看行的度是否相同,同-->即无向
    不同-->即有向
    #最小生成树-->连通但不构成环

如  
![加粗样式][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 2]  
[用prim算求最小生成树方法][prim]  
[克鲁斯卡尔算法][Link 2]  
[用邻接矩阵画图][Link 3]  
第三步结果–>即代三个点连接的含义

即典型的代指点代即可(即左代右即可)

## 三.树和森林类 ##

1.)知先序后序求二叉树  
树的四种遍历

#j即三个遍历依次往右移动代即可
    先序-->遍历顺序规则为【根左右】
    中序遍历-->遍历顺序规则-->【左根右】
    后序-->【左右根】
    层次遍历-->【即按照层次代遍历即可】

如  
已知二叉树的先序遍历序列为ABCDEFGH，中序遍历序列为CBEDFAGH，画出二叉树  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 3]  
[分析技巧–>利用分堆块进行代][Link 4]  
即定根,分堆即可  
后序直接按照上代即可  
2)知序列顺序求森林

3)知电文编码,求哈夫曼树和WPL以及字符编码  
[参考教程][Link 5]  
WPL:即最外围值乘以层次数即可  
二叉树构建法：即代比较值,离散的方法代即可代出  
例子  
如  
假设用于通讯的电文仅由8个字母A、B、C、D、E、F、G、H组成，字母在电文中出现的频率分别为：0.07，0.19，0.02，0.06，0.32，0.03，0.21，0.10。请为这8个字母设计哈夫曼编码。

#解法思路
    即代编码数关系进行代数量值,然后代排序即可完成哈弗曼树构成
    编码-->即利用层的状况代即可代出编码状况如
    A-->之前是三个层,且都在左层,所以为0

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 4]  
哈弗曼画法–>小在前,大在后。后加后排。  
4.)图的拓扑排序  
如题目  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 5]  
解法![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 6]

#思路
    BFS-->即按照表的相互关系推出即可
    DFS
    #①转边的关系
    #②边出边减为零即压栈,然后在代出即可

## 四.知表或关键字画树或画散列表且求平均长度方法 ##

1.）知表求平均查找长度类

①顺序查找法
    ②二分查找法
    
    ③二叉排序树
    ④散列表查找

[求邻接表方法][Link 6]

`①`[二分查找法][Link 7]  
即一层的节点数*层数相加除以总数类  
`②`散列表查找法  
如题  
8、将关键字序列（7 , 8 , 30 , 11 , 18 , 9 , 14）散列存储到散列表中，散列表的存储空间是一个下标从0开始的一维数组，散列函数为H(key)=(key*3)mod7 ， 处理冲突采用线性探测再散列法，要求装载因子为0.7  
（1）试画出所构造的散列表（4分）  
（2）分别计算等概率情况下，查找成功和查找不成功的平均查找长度。

[解法][Link 8]

#总结①求散列表
    #1.求装填因子
    #2.装值,相同的移动到空值里面且进行填装（即处理异常-->线性探测法）
    #②求成功的平均查找次数和不成功的平均查找次数方法
    成功的算值的查找次数再除以关键字个数即可
    不成功的算地址的平均查找次数,代除即可-->根据每个值距离后面为空的距离代算出
    
    #注意二次探测方法类

2.)构造平衡二叉树  
[平衡二叉树的原理][Link 9]

#即四种类型代换即可
    LL,RR,LR,RL
    代换结构即可

代画出平衡二叉树方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 7]

题集  
[严蔚敏数据结构习题][Link 10]

## 五,知数据序列排序 ##

[5种题型进行解][5]  
1.)希尔排序–>即对插入排序法改进代出的排序方法

#计算方法
    #①计算步长h-->第一次arr.length/2,第二次上次的结果在除二,第三次依次往下带,直至为1
    #②进行交换a[i-h]与a[h]的值

[希尔排序知识点][Link 11]  
2.)快速排序  
[快速排序知识点详解][Link 12]  
原理

①右移代交互大的值,左移代交互小的值
    ②疯狂递归

如  
![在这里插入图片描述][2020121521241497.png]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 8]  
即经过一次i,j交换后获得的值,即为一趟的结果

# 二.数据结构填空题题型 #

## 概念类 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 9]  
概念类  
①数据结构类

1、简述下列术语：算法、数据结构、存储结构、数据类型、抽象数据类型（10分）
    
    答:
    算法: 是对特定问题求解步骤的一种描述，是指令的有限序列。
    数据结构: 相互之间存在一定关系的数据元素之间的集合
    存储结构: 数据的存储结构又称为物理结构，是数据及其逻辑结构在计算机中的表示。
    数据类型: 一组值的集合以及定义与这个值集上的操作的总称。
    抽象数据类型: 抽象数据类型（ADT）是一个数据结构以及定义在该结构上的一组操作的总称。
    
    
    存储结构与逻辑结构分类
    逻辑结构:集合结构,线性结构,树状结构,图或网状结构
    存储结构:顺序存储结构与链式存储结构

②线性表的主要概念  
一个或多个数据元素的有线序列  
③栈队列的相关概念以及操作原则

队列
    在一端进行插入操作,在另一端进行删除操作的线性表
    栈
    限定仅在一段进行插入和删除操作的线性表

④串的相关概念  
0个或多个字符组成的有限序列,又名字符串

## 运算类 ##

1.)非结构类运算（即非数据结构类运算）

![在这里插入图片描述][20201214143034334.png]  
`题型①求程序段的时间复杂度`

假设n为2的乘幂,并且 n > 2,试求下列算法的时间复杂度及变量 count 的值(以n的函数形式表示)并写出计算过程.
    int Time(int n)
    { int count = 0;int x = 2;
          while(x < n/2)
         { x *= 2;count ++;
         }
    return (count);
    }
    #计算结果即直接代出为-->O（logn）

[5种类型的时间复杂度算法][5 1]  
`题型②知二维数组下标与存储内容,求一个数组下标的地址是什么`  
如题

#已知二维数组A[m][n]采用行序为主方式存储，每个元素占k个存储单元，并且第一个元的存储地址是LOC(A[0][0])，则A[i][j]的地址是 Loc(A[0][0])+((i-0)*n+(j-0))*k

`题型③二分法查找求查找需要多少次类`  
[原理分析][Link 13]  
如

有一个有序表为{ 1，3，9，12，32，41，45，62，75，77，82，95，100}，当二分查找值为82的结点时，经      4 次比较后查找成功

`④分块查找`  
概念：1.二分法查找索引表，确定要找的记录在哪一块; 2.然后再在相应块用顺序查找找到目标记录。分块查找又称为索引顺序查找。（即两种查找叠合在一起的一种查找方式）

#求法
    又称索引顺序查找，由分块有序（每一块中的关键字不一定有序，但是前一块中的最大关键字必须小于后一块中的最小关键字，即分块有序。）的索引表和线性表组成。例如把r【1....n】分为 b 块，则前 b-1 块节点数为 s = 【n/b】，最后一块允许小于或等于s。索引表是一个递增有序表。
    平均查找长度分为两部分，索引表的查找+块内的查找。
    如果以二分查找来确定块，则 ASL = log2(b+1)-1 + (s+1)/2。
    如果以顺序查找来确定块，则 ASL = (b+1)/2 + (s+1)/2。
    如果以哈希查找来确定块，则ASL=1 + (s+1)/2。

#典型例题
    对于具有300个记录的文件，采用分块索引查找法查找，其中用二分查找法查找索引表，用顺序查找法查找块内元素，假定每块长度均为30个元素，则平均查找长度为 18.4 
    #在这里s-->每块的元素个数,b均等的几块.
    #因为索引表采用二分法查找-->所以有log2(10+1)-1+(30+1)/2
    #又因为块内查找为-->(b+1)/2=5.5

2.)结构类运算(即数据结构类运算)![在这里插入图片描述][20201214143044870.png]  
①链表代算类  
–>链表代删节点类

`②队列类代运算`

#已知循环队列的存储空间大小为20，且当前队列的头指针和尾指针的值分别为8和3，且该队列的当前的长度为16
    #运算方法
    20-8,3-0#因为数组的下标从0开始
    代相加即可

`③`

若n为主串长，m为子串长，则串的古典（朴素）匹配算法最坏的情况下需要比较字符的总次数为（）。
    (n-m+1)*m

`④已知子节点类求二叉树总的节点数方法`

#如题目1-->若某二叉树有20个叶子结点，有30个结点仅有一个孩子，则该二叉树的总结点个数为69
    #解-->利用公式总度和=节点个数-1
    #分析过程
    20个叶子节点即20个度为0的节点
    30个只有一个孩子节点的节点即30个度为1的节点
    本树属于二叉树，只存在度为0 1 2三种的节点
    假设度为2的节点个数为x
    公式总度和=节点个数-1
    节点个数=50+x
    总度和=30+2x
    即 30+2x=50+x-1
    解得:x=19
    节点个数=50+19=69

题目2

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 10]  
解法

即利用性质即可
    均有性质
    no=n2+1
    叶子节点=数/2
    n2=叶子节点-1
    偶数-->n1=1  
    奇数-->n1=0

⑤二叉树<–>森林<–>树  
1.)树转换为二叉树  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 11]

2.)二叉树转换为树  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 12]  
3.)森林转换为二叉树方法  
即先将所有森林的树转为二叉树,在将树连接形成二叉树  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 13]  
4.)二叉树转森林（同理,先删线,然后在将二叉树全转为树）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 14]

#即砍右节点,向上移一步

[树,二叉树,森林之间的相互转换][Link 14]

5.)矩阵的压缩存储  
[三种矩阵压缩存储][Link 15]  
[矩阵类型判定方法][Link 16]  
①计算对称矩阵的压缩存储

上三角与下三角的判定方法-->看在主对角线的下面还是上面即可
    然后按照公式进行计算即可

②[稀疏矩阵的代运算方式][Link 17]

# 程序填空题 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 15]  
1.)[补充链表算法题目][Link 18]  
第二个在加一句Q=P->next  
即核心  
2.)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 16]  
3.二叉树三种算法

//二叉树三种遍历的递归算法 
    //先序遍历
    void PreOrderTraverse(BiTree bt){ 
    if(bt){ 
    printf("%3c",data);
    PreOrderTraverse(bt->lchild);
    PreOrderTraverse(bt->rchild);
    } 
    } 
    //中序遍历
    void InOrderTraverse(BiTree bt){ 
    if(bt){ 
    InOrderTraverse(bt->lchild);
    printf("%3c",data);
    InOrderTraverse(bt->rchild);
    }
    }
    //后序遍历
    void PostOrderTraverse(BiTree bt){ 
    if(bt){ 
    PostOrderTraverse(bt->lchild);
    PostOrderTraverse(bt->rchild);
    printf("%3c",data);
    }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70]: /images/20221120/c8cda78134794ec898d14a234d5de5be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 1]: /images/20221120/b2bec9b9aa0a4f0ca2f40c8c2d2c9038.png
[20201208092938168.png]: /images/20221120/21f583d6ef954498bcd0f90857e5c653.png
[20201208093001604.png]: /images/20221120/fe6725182a7746f28cec5cba3efbad3b.png
[Link 1]: https://www.cnblogs.com/attitudeY/p/6790224.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 2]: /images/20221120/425353ba3f814f1c843127ef69d43ffb.png
[prim]: https://blog.csdn.net/justinzengTM/article/details/82748556?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.control
[Link 2]: http://data.biancheng.net/view/41.html
[Link 3]: https://blog.csdn.net/jnu_simba/article/details/8866705
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 3]: /images/20221120/7ac82e8a768a49aaaec171403b5730cd.png
[Link 4]: https://www.cnblogs.com/xiaokang01/p/9806971.html
[Link 5]: https://www.cnblogs.com/caotao0918/p/10895387.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 4]: /images/20221120/3b46a448829b4fa5b0ec8bb286d80ab1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 5]: /images/20221120/eabb9a656d9c4befa3896c8b1cdc6e60.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 6]: /images/20221120/63a32da3f93446a989b7ba58bc5d3482.png
[Link 6]: https://jingyan.baidu.com/article/a3aad71adbfef9b1fb00968c.html
[Link 7]: https://blog.csdn.net/qq_43753724/article/details/107761090?utm_medium=distribute.pc_relevant.none-task-blog-title-2&spm=1001.2101.3001.4242
[Link 8]: https://blog.csdn.net/cnds123321/article/details/106645068
[Link 9]: https://blog.csdn.net/wxbmelisky/article/details/47755753
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 7]: /images/20221120/4f74ed03d2364cd2b59229f896121a7c.png
[Link 10]: https://www.cnblogs.com/kangjianwei101/p/5606779.html
[5]: https://wenku.baidu.com/view/8c9c2ed4c381e53a580216fc700abb68a882adc6.html
[Link 11]: https://www.jianshu.com/p/d730ae586cf3
[Link 12]: https://jingyan.baidu.com/article/d45ad148905ccf69552b80d9.html
[2020121521241497.png]: /images/20221120/de23d7322dff49f09d564f19eacfac1a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 8]: /images/20221120/099b9c73bec24c659d1a297bd57d0080.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 9]: /images/20221120/f7ccbb28aa1a4d26bbdd244b20a82653.png
[20201214143034334.png]: /images/20221120/acf172fb05514acbaa166832d7e3a430.png
[5 1]: https://blog.csdn.net/zolalad/article/details/11848739?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.control
[Link 13]: https://www.cnblogs.com/ciyeer/p/9065781.html
[20201214143044870.png]: /images/20221120/d35bf874c7af436cbdd8c57d2cf46fd4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 10]: /images/20221120/1f435eb145334a22927cb9e238ca156e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 11]: /images/20221120/bf03ba653837488c8a7ad492ab81d4b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 12]: /images/20221120/272b36e730e945fe93c61b34a3d81a5f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 13]: /images/20221120/dd5d82a6cf334996860a59464fae5127.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 14]: /images/20221120/3b8d72802f4b4d1c955734e4ee7ac597.png
[Link 14]: https://www.cnblogs.com/MyStringIsNotNull/p/8279126.html
[Link 15]: http://data.biancheng.net/view/183.html
[Link 16]: https://blog.csdn.net/sunhuaqiang1/article/details/51296861
[Link 17]: https://blog.csdn.net/meiyubaihe/article/details/29170915
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 15]: /images/20221120/efe42c2d3355420ea2594f00fb4fc57f.png
[Link 18]: https://blog.csdn.net/fu_jian_ping/article/details/88756348
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQyMDQw_size_16_color_FFFFFF_t_70 16]: /images/20221120/9cba2bbac41448bba3cdbb946fc52451.png