《数据结构》

考研408复习
复习顺序为《数据结构》、《组成原理》、《操作系统》、《计算机网络》
复习教材：专业408教材（4本）+《王道考研复习指导》

一、线性表

1.1基本概念

1.2线性表的实现
1.2.1顺序存储
·数据结构定义：
（静态）
#define MaxSize 20
typedef struct {
int data[MaxSize];
int length;
}SqList;
（动态）
#define INITSIZE 10
#define INCREMENT 10
tpydef struct{
int *elem; //存储空间基址
int length; //线性表当前长度
int listSize; //存储容量
}SqList;
·顺序表：顺序or随机存取（访问），存储密度大
逻辑相邻=》物理相邻
建立有序单链表Tmin=O(nlog2n(=)
查找=O(1)；插入=删除=按值查找=O(n)
有序时按序查找（折半查找）=O(log2n)
·需要掌握的算法：
数组逆置Reverse
二分（折半）查找
多个数组合并为一个有序数组Merge
·合并两个长度分别为m和n的有序表，最坏的比较次数为m+n-1

1.2.2链式存储
·数据结构定义：
typedef struct Node{
int data；
struct Node* link；
}Node；
·单链表：非随机存取
（头\尾插法）建立链表=按序号\值查找结点=求表长=O(n)
插入\删除结点O(1)
增加头节点：方便运算的实现
·双链表：结点中有两个指针：prior和next
·循环链表：最后一个结点的指针指向头结点
判空：头结点的指针等于头结点
任意结点遍历链表
可用带尾指针的循环链表来表示队列
·循环双链表，判空：L—>priorL&&L—>next=L
·静态链表：借助数组描述线性表的链式存储结构，需预先分配一块连续的内存空间
结点分为数据域和指针域（结点的相对地址，数组下标，游标）
以next-1为结束标志
·一个链表最常用的操作是：
在末尾插入结点和删除结点：带头节点的双循环链表
在最后一个元素后插入和删除第一个元素：不带头结点有尾指针的循环单链表

1.3线性表的应用

二、栈、队列和数组

2.1栈和队列的基本概念
·后进先出LIFO
·n个不同元素进栈，不同排列个数：(1/n+1)C^n(2n)
·操作受限的线性表（逻辑结构）

2.2栈和队列的顺序存储结构
·数据类型定义
#define MaxSize 50
（栈）
typedef struct{
int data[MaxSize];
Int top;
}SqStack;
（队列）
typedef struct{
int data[MaxSize];
int front,rear;
}SqQueue;

·进栈push：（不满）先加一后赋值；出栈pop：（不空）先取值后减一
·进队：送队尾，尾加一；出队：取队头，头加一
·共享栈：栈底在两端，栈顶向中间延伸，栈空：top0=-1/top1=MaxSize；栈满：top0-top1=1
·顺序队列：假溢出
解决：循环队列，逻辑上的环，front到队尾取余回0
首(尾)加一：Q.front(rear)=(Q.front(rear)+1)%MaxSize
队列长度：(Q.rear+MaxSize-Q.front)%MaxSize
判空判满：
（1）牺牲一个单元：空：Q.front=Q.rear；满：(Q.rear+1)%MaxSizeQ.front
（2）增设表示元素个数的数据成员：空：Q.size0；满：Q.sizeMaxSize
（3）增设tag成员数组:空：tag0&&Q.frontQ.rear；满：tag1&&Q.front==Q.rear

2.3栈和队列的链式存储结构
·链栈，不会上溢，单链表实现，所有操作表头进行
·数据类型定义：
（栈）
typedef struct LinkNode{
int data;
struct LinkNode *next;
}*LiStack
（队列）
typedef struct LinkNode{
int data;
struct LinkNode *next;
}LinkNode;
typedef struct{
LinkNode *front,*rear;
}LinkQueue;
·可用做C语言标识符：字母或下划线_开头，不能以数字开头
·队空：Q.frontQ.rearNULL
·双端队列：
输出受限的双端队列Lo：只有一端允许输出=栈+可以从栈底入栈的栈
输入受限的双端队列Li：只有一端允许输入=两个栈底相连的栈
例：输入顺序为1234，
能由Li得到，Lo不能的：4132；Lo可以Li不能：4213
即不也不：4231

2.4多维数组的存储
·一维数组：Ai=A0+iL（L为数组元素大小）
·二维数组：A[M,N]
行优先：Ai,j=A(0,0)+[i(N+1)+j]L
列优先：Ai,j=A(0,0)+[j(M+1)+i]*L
2.5特殊矩阵的压缩存储 A[n,n],Ai,j Bk
·压缩存储：二维映射到一维，建立下标间关系；
多个值相同的元素分配一个空间，零元素不分配空间
目的：减少不必要的存储空间
·对称矩阵：k=[i(i-2)]/2+j-1(i>=j)，j>i时i，j互换
A[1…n][1…n] —> B[n(n+1)/2]
·三角矩阵：下三角矩阵中上三角部分均为同一元素，最后补上即可
A[1…n][1…n] —> B[n(n+1)/2+1]
·（三）对角矩阵/带状矩阵：非零元素集中在主对角线边上
k=2i+j-3；i=(k+1)/3+1（向下取整）；j=k-2i+3
·稀疏矩阵：非零元素<<零元素，构成三元组<行号，列号，元素值>
用三元组表或十字链表存储
压缩后失去了随机存取的特性
·在计算转化后下标时，看清存上三角还是下三角；若存上三角给下三角元素，需先交换行列

2.6栈、队列和数组的应用
·栈：括号匹配、（后缀）表达式求值、中缀转后缀、递归、进制转换、迷宫求解
·队列：层次遍历、（计算机系统）速度不匹配、多用户竞争
·括号匹配：
初始空栈，顺序读入；
右括号，与栈顶匹配？匹配相消pop，不匹配则不合法
左括号push
结束栈空？
·中缀表达式转化为后缀表达式
空栈，push栈底元素#，顺序读入
操作数：直接输出
操作符：栈顶优先级>入栈优先级？pop：push
·后缀表达式求值
顺序读入：
操作数：push
操作符：pop✖️2（X与Y）
XY=Z，Zpush
·通常非递归算法的效率高于递归算法
·递归算法中用于保存调用过程的信息栈，越底层越外层，最底层为main
·广度优先搜索需要使用队列作为辅助空间
·给一棵二叉树的前序遍历序列，问可能的中序遍历序列==给入栈顺序求可能的出栈顺序

*串
1、定义与实现

2、串的模式匹配—KMP算法

三、树与二叉树

3.1基本概念
·树是逻辑结构
·根结点高度为1，层数为1；深度自根向下++，高度自叶结点向根结点++
·树中结点的最大度数（度数：孩子个数）为树的度
·路径长度：路径上经过的边的个数；路径上从上至下的
·总结点数=所有结点度数之和+1（根）
·度为m，第i层至多有m^(i-1)个结点
·度为m，高为h，至多有(m^h-1)/(m-1)个结点
·度为m，总结点树为N，Hmin=logm(n(m-1)+1)（向上取整）

3.2二叉树
3.2.1二叉树的定义及其主要特征

·二叉树是有序树，即使树中结点只有一棵子树，也需区分是左子树还是右子树
·特殊的二叉树：
满二叉树：n=2^h-1，编号为i的结点，父节点编号：i/2(向下取整)，孩子结点编号：2i和2i+1
完全二叉树： （1）i<=n/2(向下取整)为分支结点，否则为叶子结点
（2）n为偶数：只有一个度为1的结点，无右孩子；n为奇数，左右孩子均有
（3）结点数N，H=log2(n+1)（向上取整）或log2n（向下取整）+1
高度为h，最少结点数：2^(h-1)
二叉排序树：Lkey<Nkey<Rkey
平衡二叉树：|平衡因子|<=1
·性质：
n0=n2+1
第k层结点数max=2^(k-1)
高度为h，Nmax=2^h-1

3.2.2二叉树的顺序存储结构和链式存储结构
·顺序适用：满/完全二叉树，按层次遍历，空结点置0（可能造成空间利用率低）
·链式存储结构：
typedef struct BiTree{
int data;
struct BiTree *lchild,*rchild;
}BiTNode,*BiTree;
·在含有n个结点的二叉链表中，有n+1个空链域
n+1=2n-n+1：总链域-每个结点的父链+根无父
·利用空链域构造线索链表
·偶数个结点的二叉树，度为1的结点为奇数

3.2.3二叉树的遍历
·先/中/后序遍历中“序”=根
·遍历递归算法
void Pre/In/PostOrder(BiTree T){ //先/中/后序
if(T!=NULL){
//先序放这 visit(T);
Order(T->lchild); //递归遍历左子树
//中序 visit(T);
Order(T->rchild); //递归遍历右子树
//后序 visit(T);
}
}
·时间复杂度：O(n)
·递归遍历中，栈的深度=树的深度（树高）
·先/中/后序遍历非递归（借助栈）
中序思路（1）借助栈，沿着根的左孩子，向下，依次入栈，直至为空
（2）出栈顶元素，并访问其右孩子
（3）若无右孩子，继续（2）；若不空，对右子树执行（1）

算法如下：
void InOrder2(BiTree T){
//InitStack(S);
BiTree *p=T;
while(p||!IsEmpyt(S)){ //p或栈不空
if§{
//先序放这visit§
Push(S,p);
p=p->lchild;
}else{
Pop(S,p);visit§;
p=p->rchild;
}
}
}
·后序遍历非递归（麻烦，补充），修改else中内容
else{
GetTop(S,p); //p左为空时，也不先出栈，当左右子树均被访问后才会出栈
if(p->rchild&&p->rchild!=r) //r用于指示右子树是否已被访问过，r初始为空
p=p->rchild;
else{
Pop(S,p);
visit(p->data);
r=p; //记录最近访问过的结点
p=NULL; //访问过后重置p指针
}
}
·后序遍历的特性可被用于设计算法例如：
求根到某结点的路径、两个结点的最近公共祖先

·层次遍历（借助队列）
1、思路：
（1）根入队
（2）出队并访问后，将其左、右孩子入队（若有）
（3）重复（2），直至队列空
2、算法
void LevelOrder(BiTree T){
//InitQueue(Q);
BiTree p=T;
EnQueueu(Q,T);
while(!IsEmpty(Q)){
DeQueue(Q,p);
visit§;
if(p->lchild!=null) EnQueue(Q,p->lchild);
If(p->rchild!=null) Enqueue(Q,p->rchild);
}
}
3、应用
（1）求树高（2）某层/每层的结点个数=求树的宽度（3）求树的度
（4）判断是否为完全/满二叉树

·唯一确定一棵二叉树：先序/后序/层序+中序（中序来分割左右）

3.2.4线索二叉树的基本概念和构造
·线索二叉树
构造：lchild｜ltag｜data｜rtag｜rchild
l/rtag= 0:l/rchild域指示结点的左/右孩子
1:l/rchild域指示结点的前驱/后继（即结点没有左/右孩子）
目的：加快查找结点的前驱或后继的速度
是一种物理结构
数据结构描述：
typedef struct ThreadNode{
int data;
struct ThreadNode *lchild,*rchild;
int ltag,rtag;
}ThreadNode, *ThreadTree;

·二叉树化为线索二叉树，一次遍历，右孩子空连接后继；左孩子空连接前驱
·找后继：
中序：rtag1？右链后继：右子树的第一个（最左）结点
前序：有左则左；无左有右则右；叶则右链
后序： proot，后继为空；
p为pre->rchild或者p为pre->lchild&&per->rchild==null，后继为pre（父结点）
p为pre->lchild&&per->rchild!-null，后继为pre的右子树按后序遍历的第一个结点

·非空二叉树，先序遍历与后序遍历相反：该二叉树只有一个叶结点
·n个结点的线索二叉树含有n+1个线索
·左子树为空，先序线索化，有两个空链域，根的前驱与最右后继
·后序线索树的遍历需要栈的支持
·先序遍历与后序遍历相反，则二叉树的高度=结点数，即一个结点不可能同时有左右孩子
（相同，则只有一个根结点）
·给先序序列，求可构造的不同二叉树
=给入栈序列，求出栈序列个数（卡特兰数）
·涉及算法题型：
二叉链表，非递归，求树高
前序/后序/层序+中序建树
判定二叉树是否为完全/满二叉树
求叶子结点数、双分支结点数
查找值为x的结点，并打印路径

3.3树、森林
3.3.1树的存储结构
·双亲表示法（顺序存储）
连续空间，数组存储，伪指针指示父节点，根结点下标0，指针域-1
孩子求父易，父求孩子需遍历
与二叉树的顺序存储区分，二叉的下标有指示结点关系的作用，树无，还多个域
并查集使用
·孩子表示法
数组线性单链表，结点顺序排列，后链孩子结点
父找孩子易，孩子找父需遍历
·孩子兄弟法（二叉树表示法）
实现树转化为二叉树
*firstchild，*nextsibling
3.3.2森林与二叉树的转换
·树转二叉树：左孩子右兄弟，根无兄弟，即无右子树
·森林转二叉，同上，树数>=1，根可能有右子树
3.3.3树和森林的遍历
·树：先根遍历、后根遍历
·森林：先序：从第一棵树开始先序遍历，直至所有
后序/中序：从第一棵树/二叉树开始后序/中序遍历
遍历序列相当于森林转为二叉树后的中序遍历
·高度为h的满二叉树，对应的森林所含树的个数为h
·
·F为森林，T为树，B为转化后的二叉树
（1）F中有n个非终端结点，B中右指针域为空的结点有n+1个
（非终端结点度最右孩子的右链+森林最后一棵树的右链）
（2）F的叶结点数n0=B中左孩子为空的个数
（3）T的结点数为N，叶结点数为n0，B中无右孩子的结点个数为N-n0+1
（4）F有m条边，n个结点，F中有n-m棵树

3.4树与二叉树的应用
3.4.1哈夫曼(Huffman)树和哈夫曼编码
·带权路径长度WPL=∑wili（结点权值根到结点的路径长度的求和）路径长度=经过边数
·哈夫曼树（最优二叉树）：在含有n个带权结点的二叉树中，WPLmin
·哈夫曼树的构造：每次选择权值最小的两个结点作为新结点的左右孩子
若有n个结点，构造新建了n-1个结点
构造完成的哈夫曼树的N=2n-1，不存在度为1度结点
·哈夫曼编码：可变长度编码（相对：固定长度编码）
应用：数据压缩，前缀编码
·前缀编码：没有一个编码是另一个编码的前缀

3.4.2并查集及其应用
·3种操作： （1）Initial(S)：元素初始化（每个元素都是一个根，指针域均为-1）
（2）Union(S,Root1,Root2)合并，Root2并入Root1（要求不相交）
（3）Find(S,x)查找，元素x所在子集和，返回子集和的根结点
·存储：使用树的双亲指针数组表示法
元素编号0–n，S[i]的值：非根结点：父节点数组下标；根结点：该树总结点数的负值
·应用：（1）实现克鲁斯卡尔算法（2）判断无向图的连通性
·在长度为n的并查集进行查找操作的时间复杂度：O(n)

四、图

4.1基本概念
·E：弧/边；V：顶点
·有向图<>；无向图( )
·简单图：无重边，无环；多重图（与简单图相对）
·完全图（简单完全图）
无向图：任意两个顶点间都存在边，|E|=n(n-1)/2
有向(完全)图：任意两个顶点间都存在方向相反的两条弧，|E|=n(n-1)
·子图：G’的E’和V’集是G的子集
（不是所有V，E子集都能构成G的子图）
·生成子图：V(G’)=V(G)
·连通、连通图、连通分量（无向图）
连通：顶点v到w有路径存在
连通图：任意两个顶点都连通（否则非连通图）
连通分量：极大连通子图
·强连通，强连通图，强连通分量（有向图）
强连通：顶点v到w，w到v之间都有路径
强连通图：任意两个顶点都强连通
强连通分量：极大强连通子图
·生成树，生成森林（无向图）
生成树：极小连通子图（与连通分量区分）
生成森林：非连通图中，连通分量的生成树，构成森林
·顶点的度（有/无向图）；入度和出度（有向图）
度：依附于某个顶点的边
入度：指进来（为终点）；出度：指出去（为起点）
·边上带有权值的图为带权图（网）
·当|E|<|V|log|V|时为稀疏图，相对稠密图
·路径、路径长度和回路
路径：由顶点和相邻顶点序偶构成的边所形成的序列
路径长度：路径边数
回路：一条路径，起点=终点
·简单路径：顶点序列中，顶点不重复出现
简单回路：除起点和终点外不重复
·距离：最短路径
·有向树：一个顶点入度为0，其余顶点入度为1的有向图
·补充：
（1）n个顶点的非连通图，最多有(n-1)(n-2)/2条边（n-1个顶点构成完全图，此时再加一条边则变连通图）
（2）n个顶点的连通图，最少有n-1条边
（3）n个顶点的强连通图，最少有n条边（环路）
（4）有向完全图一定是强连通图
（5）连通图的生成树，-e=非连通图；+e=形成回路
（6）n个顶点，e条边的无向图，顶点的度之和=2*e
（7）n个顶点，e条边的有向图，总入度=总出度=e
（8）n个顶点，e>n-1，必有环（不一定连通！）
（9）n个顶点的图为环，则有n棵生成树
n个顶点，e条边的无向图为森林，森林中有n-e棵树
（10）若有向图中存在拓扑序列，则该图不存在回路

4.2图的存储及基本操作
4.2.1邻接矩阵
·一维数组（存顶点）+二维数组（存边）
·数据结构定义
#define MaxVertexNum 100
//typedef char VertexType; 顶点数据类型
//typedef int EdgeType ; 边数据类型
typedef struct{
char Vex[MaxVertexNum];
int Edge[][MaxVertexNum][MaxVertexNum];
int vex us,arcnum;
}MGraph;
·无向图的邻接矩阵是对称矩阵（唯一）（可只储存上或下三角，规模大可使用压缩存储）
·空间复杂度：O(n^2)
·对于有向图的邻接矩阵，第i行非零元素个数=顶点i的出度；第i列，入度
·适用于稠密图
·A为邻接矩阵，A^n[i][j]的值：顶点i到顶点j长度为n的路径数

4.2.2.邻接表
·一个顺序表（存n个顶点）+n个单链表（存边）
·顶点结点：data｜firstarc；边表结点：adjvex｜nextacr（一条弧的起点｜指针指向该弧终点）
·数据结构：
typedef struct ArcNode{ //边表结点
int adjvex;
struct ArcNode *next;
}ArcNode;
typedef struct VNode{ //顶点结点
char data;
ArcNode *first;
}VNode,AdjList[MaxVertexNum];
typedef struct{
AdjList vertices; //邻接表
int vexnum，arcnum； //顶点数，弧数
}ALGraph；
·存储空间：无向图=V+2E；有向图：V+E（与顶点数和边数都有关）
·适用于稀疏图
·有向图的邻接表，出度=该顶点的单链表结点数；入度：需遍历整个表

·比较：
（1）邻接矩阵易判断两点是否相连，确定边数（找邻边）需遍历
（2）邻接表易找邻边，判断相连需遍历

4.2.3邻接多重表、十字链表
·十字链表：有向图度链式存储结构
弧结点：tailvex｜headvex｜hlink｜tlink｜info
尾域｜头域｜链域（弧头相同的下一条弧）｜链域（弧尾相同）
顶点结点：data｜firstin｜firstout
数据信息｜以该顶点为弧头的第一个弧结点｜为弧尾
·邻接多重表：无向图的链式存储
边结点：mark｜ivex｜ilink｜jvex｜jlink｜info
标志域｜顶点i｜依附于i的下一条边｜顶点j｜依附于j的下一条边｜信息域
顶点结点：data｜firstedge
顶点信息｜第一条依附于该顶点的边
与邻接表的差别：同一条边，邻接表用两个结点表示，多重表用一个
·补充：
（1）若一个有向图度邻接矩阵度对角线下元素均为0，这该图的拓扑序列必存在
（2）一个图的邻接矩阵表示唯一，邻接表不唯一

4.3图的遍历
4.3.1深度优先搜索DFS

4.3.2广度优先搜索BFS

4.4图的基本应用
4.4.1最小（代价）生产树

4.4.2最短路径

4.4.3拓扑排序

4.4.4关键路径

• G为无向连通图，当G中度为奇数的顶点个数为不大于2的偶数（0或2）时，G中存在：包含所有边且长度为|E|的路径

• BFS，广度优先遍历，借助队列

• DFS，深度优先遍历，借助栈

• BFS与DFS算法复杂度
  空间复杂度：O(|V|)
  时间复杂度：
  $$邻接矩阵：O(|V{|}^2)$$$$邻接表：O(|V|+|E|)$$
  |V|：结点数；|E|：边数

• 最小生成树：
  Prim：边稠密，时间复杂度:$$O(|V{|}^2)$$
  Kruskal：边稀疏，多顶点，时间复杂度:$$O(|E|log|E|)$$

• 最短路径
  Dijkstra：单源，贪心，时间复杂度:$$O(|V{|}^2)$$
  Floyd：所有顶点对，不断加入中间结点，时间复杂度:$$O(|V{|}^3)$$
  |V|次Dijkstra➡Floyd

• DAG：有向无环图

• 拓扑排序：依次输出并删除ID=0的顶点

五、查找

5.1基本概念

5.2顺序查找法

5.3分块查找法

5.4折半查找法

5.5树型查找
5.5.1二叉树搜索树/二叉排序树BST
5.5.2平衡二叉树AVL
·高度为h最少结点数：N0=0，N1=1，Ｎ2=2，Nh=N(h-1)+N(h-2)+1
例：N3=N2+N1+1=4，N5=N4+N3+1=7+4+1=12
·构造平衡二叉树
·计算查找成功/失败的平均查找长度ASL
把构造好的平衡二叉树补上“失败结点”
成功ASL=（层数该层结点数之和）/总结点数（根结点为第一层）
失败ASL=（其父节点层数该层结点数之和）总失败结点数

5.5.3红黑树

5.6B树和B+树
·多路平衡查找树（所有节点的平衡因子均为0）
·m阶B树需满足：（可为空树，若不空时）
（1）m为所有节点中孩子数最大值（即m叉树）
（2）非叶结点的结构为：n（关键字个数）｜Pi（指向子树的指针）｜Ki（关键字）｜Pi+1｜Ki+1
（3）除根结点，m/2（向上取整）-1<=n<=m-1 ，
例如，5阶B树，每个节点的关键字数=[2，4]；子树个数[3，5]（关键字数+1，即指针个数）

5.7散列(Hash)表
·构造散列表：
直接地址法：H(key)=akey+b
除留余数法（一般使用）：H(key)=key%p；
数字分析法；平方取中法
·处理冲突：
开放地址法：Hi=[H(key)+di]%m
其中：Hi为散列函数；di为增量序列；m为表长
增列序列取法不同，一般有：
线性探测法(0,1,2,3,…)；平方（二次）探测法(0,1^2,-12,2^2,-22,…)；
双散列法：Hi=(H(key)+iHash2(key))%m；伪随机数列法
拉链法（链接法）：（考法）构造散列链表，计算平均查找长度ASL
·装填因子：

5.8字符串模式匹配（KMP算法）
·模式匹配：求子串在主串中首次出现的位置
·简单模式匹配（暴力匹配），主串长度为n，模式串长度为m，时间复杂度为O(nm)
·KMP算法时间复杂度：O(n+m)，优点：主串不回溯
·next[j]：在子串的第j个字符与主串匹配失败时，跳到子串的第next[j]位置重新与主串当前位置比较
·手工求解next数组：
写子串的部分匹配值PM序列（最长前后缀长度）
将序列整体右移一位，最左端补-1
整体加1
·程序求解next数组：（设子串为ch[]）
求next[j]时，看ch[j-1]？=ch[next[j-1]]
等则next[j]=next[j-1]+1
不等则继续往前找ch[next[next[j-1]]，直到找到相等的或到0，若找到的为ch[k]，则next[j]=k+1
·nextval数组：防止Pj=Pnext[j]出现而导致无意义的相同字符的比较
在get_next后加入修正next的程序：核心是：将next[j[修正为next[next[j]]，直至两者不相等
·出现失配后，假设位置为s[i],t[j]，则下一次开始匹配的i，j值为：
i：主串不回溯，i=i
j：构造子串的next数组，j=next[j]
5.9查找算法的分析及应用

• 具有n个结点的k叉树的高$${\log }_{k}n(向下取整)+1$$
• 二叉排序树的中序遍历是递增有序序列

六、排序

6.1基本概念

6.2直接插入排序

6.3折半插入排序

6.4冒泡排序

6.5简单选择排序

6.6希尔排序(shell sort)

6.7快速排序

6.8堆排序

6.9二路并归排序(merge sort)

6.10基数排序

6.11外部排序

6.12排序算法的分析和应用

重要代码

（不会涉及所有代码，筛选自各位大佬压的重点代码，大部分摘录自王道书；*选择记忆）
一、线性表

• 顺序表定义
• 顺序表增删改查
• 单链表定义
• 单链表基本操作（头/尾插法、遍历、插入、删除）
• *双链表
• *循环链表
• *静态链表

二、栈、队列和数组
（如只需使用栈与队列这种数据结构，可直接使用C++的STL，补充在后面）

• *实现栈
• *实现队列

三、串（无）

四、树与二叉树

• 顺序存储结构
• 链式存储结构
• 先序遍历
• 中序遍历
• 后序遍历
• 树与二叉树

五、图

• 数据结构与基本操作
• 邻接矩阵
• 邻接表
• 深度优先搜索
• *广度优先搜索

六、查找

• 顺序查找
• 折半查找

七、排序

• 快速排序
• *冒泡排序
• *选择排序
• *插入排序
• *归并排序
• *计数排序
• *桶排序
• *基数排序

补充

C++STL

一、六大组件

1. 容器Container：一种数据结构
2. 迭代器/游标iterator
3. 算法Algorithm
4. 仿函数Function object
5. 迭代适配器Adapt
6. 空间适配器Allocator

关于容器：
分为顺序容器：list（双向链表）、vector（动态数组）、dequeue（双端队列）；关联容器：set（集合，有序且唯一）、map（地图，以key排序且唯一）；
stack（栈）为vector的Adapt；queue（队列）为dequeue的Adapt

二、使用

//
#include <C>	//添加相应头文件，例：#include <vector>
using namespace std;	//添加std命名空间

//实例化容器
typedef C<dataTpype> Cname();
		//例：typedef vector<int> vec(2,4)	//{4,4}
		//					     vec(4)		//{0,0,0,0}
		//						 vec(a,a+i)	//数组a,从0~i-1个元素

//声明迭代器
C<>::iterator itname;	//例：vector<int>::iterator it;

//通过迭代器访问容器中数据
//例，输出vector中所有数据
for(i=vec.begin();i!=vec.end();i++)
	std::cout<<*it<<end;
//例，添加数据
vec.insert(it,1);

三、常用函数
(c为实例化后容器名）

• c.size()
• c.empty()
• c.push_back()
• c.pop_back()
• c.push_front()
• c.pop_front()
• c.back()
• c.front()
• c.erase()
• c.remove()