时隔多日的复更。
本鶸备考过程中整理了一下部分的数据结构的笔记以及严奶奶书上的代码。
不算全面，笔记有错的地方还请指出嗷QWQ。
1 #include<bits/stdc++.h>
2 using namespace std;
3
4
5 /*基本操作
6 InitList(&L); //构造一个空的线性表
7 DeStroyList(&L); //销毁一个线性表
8 ClearList(&L); //置空表
9 ListEmpty(L); //判断空表
10 ListLength(L); //返回L中数据元素的个数
11 GetELem(L,i,&e); //返回L中第i个数据元素的值
12 LocateElem(L,e,compare()); //和e满足位序
13 PriorElem(L,cur_e,&pre_e); //返回前驱
14 NextElem(L,cur_e,&pre_e); //返回后继
15 ListInsert(&L,i,e); //在第i个前插入元素e
16 ListDelete(&L,i,&e); //删除L的第i个数据元素
17 ListTraverse(L,visit()); //没个数据元素访问一次
18
19 */
20
21 //线性表
22 #define LIST_INIT_SIZE 100
23 #define LISTINCREMENT 10
24 typedef struct{
25 ELemType *elem; //基址
26 int length; //长度
27 int listsize; //分配的存储容量
28 }SqList;
29
30 Status InitList(SqList &L){
31 L.elem = (ELemType *)malloc(LIST_INIT_SIZE*sizeof(ELemType));
32 if(!L.elem) return ERROR;
33 L.length = 0; //空表长度为0
34 L.listsize = LIST_INIT_SIZE; //初始存储容量
35 return OK;
36 }
37
38 Status ListInsert(SqList &L,int i,ELemType e){
39 if(i < 1 || i > L.length + 1) return ERROR;
40 if(L.length >= L.listsize){
41 newbase = (ELemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ELemType));
42 if(!newbase) return ERROR;
43 L.elem = newbase;
44 L.listsize += LISTINCREMENT;
45 }
46 q = &(L.elem[L.length-1]; p >= q; --p) *(p+1) = *p;
47 *q = e;
48 ++L.length;
49 return OK;
50 }
51
52 Status ListDelete(SqList &L,int i,ELemType &e){
53 if((i<1)||(i>L.length)) return ERROR;
54 p = &(L.elem[i-1]);
55 e = *p;
56 q = L.elem + L.length-1;
57 for(++p; p<= q; ++p) *(p-1) = *p;
58 --L.length;
59 return OK;
60 }
61
62
63 void MergeList(SqList La,SqList Lb,SqList &Lc){
64 pa = La.elem; pb = Lb.elem;
65 Lc.listsize = Lc.length = La.length + Lb.length;
66 pc = Lc.elem = (ELemType *)malloc(Lc.listsize * sizeof(ELemType));
67 if(!Lc.elem) return ERROR;
68 pa_last = La.elem + La.length-1;
69 pb_last = Lb.elem + Lb.length-1;
70 while(pa <= pa_last && pb <= pb_last){
71 if(*pa <= *pb) *pc++ = *pa++;
72 else *pc++ = *pb++;
73 }
74 while(pa <= pa_last) *pc++ = *pa++;
75 while(pb <= pb_last) *pc++ = *pb++;
76 }
77
78 //链表
79 typedef struct LNode{
80 ELemType data;
81 struct LNode *next;
82 }LNode, *LinkList;
83
84 Status ListInsert(LinkList &L,int i,ELemType e){
85 p = L; j = 0;
86 while(p && j < i-1 ){ //寻找第i-1个结点
87 p = p->next;
88 ++j;
89 }
90 if(!p || j > i-1) return ERROR;
91 s = (LinkList)malloc(sizeof(LNode));
92 s->data = e; s->next = p->next;
93 p->next = s;
94 return OK;
95 }
96
97 Status ListDelete(LinkList &L,int i,ELemType &e){
98 p = L; j = 0;
99 while(p->next && j < i-1){
100 p = p->next; ++j;
101 }
102 if(!(p->next) || j > i-1) return ERROR;
103 q = p->next; p->next = q->next;
104 e = q->data; free(q);
105 return OK;
106 }
107
108 void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){
109 pa = La->next; pb = Lb->next;
110 Lc = pc = La;
111 while(pa && pb){
112 if(pa->data <= pb->data){
113 pc->next = pa; pc = pa; pa = pa->next;
114 }
115 else{
116 pc->next = pb; pc = pb; pb = pb->next;
117 }
118 }
119 pc->next = pa ? pa : pb;
120 free(Lb);
121 }
122
123
124
125 //双向链表
126 typedef struct DuLNode{
127 ELemType data;
128 struct DuLNode *prior;
129 struct DuLNode *next;
130 }DuLNode,*DuLinkList;
131
132 Status ListInsert(DuLinkList &L,int i,ELemType e){
133 if(!(p = GetELem(L,i))) return ERROR;
134 if(!(s = (DuLinkList)malloc(sizeof(DuLNode)))) return ERROR;
135 s->data = e;
136 s->prior = p->prior; p->prior->next = s;
137 s->next = p; p->prior = s;
138 return OK;
139 }
140 Status ListDelete(DuLinkList &L,int i,ELemType &e){
141 if(!(p = GetELem(L,i))) return ERROR;
142 e = p->data;
143 p->prior->next = p->next;
144 p->next->prior = p->prior;
145 free(p); return OK;
146 }
147
148
149
150
151 int main(){
152
153 return 0;
154 }
1 #include<bits/stdc++.h>
2
3 using namespace std;
4
5
6 #define MaxSize 50
7 typedef struct {
8 ElemType data[MaxSize]; //存放栈中元素
9 int top; //栈顶
10 }SqStack;
11
12 //进栈
13 bool Push(SqStack &S,ElemType x){
14 if(S.top == MaxSize-1) return FALSE:
15 S.data[++S.top] = x; //指针先加1，再入栈
16 return TRUE;
17 }
18
19 //出栈
20 bool Pop(SqStack &S,ElemType &x){
21 if(S.top == -1) return FALSE;
22 x = S.data[S.top--]; //先出栈，指针再减1
23 return true;
24 }
25
26 //栈顶
27 bool GetTop(SqStack S,ElemType &x){
28 if(S.top == -1) return FALSE;
29 x = S.data[S.top];
30 return TRUE;
31 }
32
33 //初始化如果是S.top = 0;
34 //入栈 S.data[S.top++]; 出栈 S.data[--S.top];
35
36 typedef struct Linknode{
37 ElemType data; //数据域
38 struct Linknode *next; //指针域
39 }*LiStack; //栈类型顶定义
40
41
42
43 //队列
44 typedef struct{
45 ElemType data[MaxSize]; //存放队列元素
46 int front,rear; //队头和队尾指针
47 }SqQueue;
48
49 //循环队列
50 //入队
51 bool EnQueue(SqQueue &Q，ElemType x){
52 if((Q.rear+1) % MaxSize == Q.front) return FALSE;
53 Q.data[Q.rear] = x;
54 Q,rear = (Q.rear + 1) % MaxSize;
55 return TRUE;
56 }
57
58 bool DeQueue(SqQueue &Q,ElemType &x){
59 if(Q.rear == Q.front) return false;
60 x = Q.data[Q.front];
61 Q.front == (Q.front + 1) % MaxSize
62 return true;
63 }
64
65
66
67 int main(){
68
69
70 return 0;
71 }
1 #include<bits/stdc++.h>
2 using namespace std;
3
4 /*
5 基本操作
6 InitBiTree(&T); //构造空二叉树
7 DestoryBiTree(&T); //销毁二叉树
8 CreateBiTree(&T,definition); //按照definition构造二叉树
9 ClearBiTree(&T); //清空二叉树
10 BiTreeEmpty(T); //判断是否为空二叉树，空为True
11 BiTreeDepth(T); //返回T的深度
12 Root(T); //返回T的根
13 Value(T,e); //e为结点，返回e的值
14 Assign(T,&e,value); //结点e赋值为value
15 Parent(T,e); //返回e的双亲节点
16 LeftChild(T,e); //返回e的左孩子
17 RightChile(T,e); //返回e的右孩子
18 LeftSibling(T,e); //返回e的左兄弟
19 RightSibling(T,e); //返回e的右兄弟
20 InsertChild(T,p,LR,c); //p指向T中结点，LR=0/1，插入c为T中p所指结点的左或右子树
21 DeleteChild(T,p,LR); //p指向T中结点，LR=0/1,删除T中p所指结点的左或右子树
22 PreOrderTraverse(T,Visit()); //先序遍历
23 InOrderTraverse(T,Visit()); //中序遍历
24 PostOrderTraverse(T,Visit()); //后序遍历
25 LevelOrderTraverse(T,Visit()); //层序遍历
26 */
27
28
29 //二叉链表存储
30 typedef struct BiTNode{
31 TElemType data;
32 struct BiTNode *lchild,*rchild;
33 }BiTNode,*BiTree;
34
35 //基本操作
36 Status CreateBiTree(BiTree &T);
37 Status PreOrderTraverse(BiTree T,Status(* Visit)(TElemType e));
38 Status InOrderTraverse(BiTree T,Status(* Visit)(TElemType e));
39 Status PostOrderTraverse(BiTree T,Status(* Visit)(TElemType e));
40 Status LevelOrderTraverse(BiTree T,Status(* Visit)(TElemType e));
41
42 //Visit函数
43 Status PrintElement(TElemType e){
44 printf(e);
45 return OK;
46 }
47
48 /***********课本**************/
49 //二叉链表的先序遍历
50 //递归
51 Status PreOrderTraverse(BiTree T, Status(* Visit)(TElemType e)){
52 if(T){
53 if(Visit(T->data)){
54 if(PreOrderTraverse(T->lchild,Visit)){
55 if(PreOrderTraverse(T->rchild)) return OK;
56 }
57 }
58 return ERROR;
59 }
60 else return OK;
61 }
62
63
64 //二叉链表的中序遍历
65 //借助栈，非递归
66 Status InOrderTraverse(BiTree T,Status(* Visit)(TElemType)){
67 InitStack(S); Push(S,T); //根指针入栈
68 while(!StackEmpty(S)){
69 while(GetTop(S,p) && p) Push(S,p->lchild); //向左走到尽头
70 Pop(S,p); //空指针退栈
71 if(!StackEmpty(S)){ //访问结点向右一步
72 Pop(S,p);
73 if(!Visit(p->data)) return ERROR;
74 Push(S,p->rchild);
75 }
76 }
77 return OK;
78 }
79
80 //二叉链表的中序遍历
81 //借助栈,非递归
82 Status InOrderTraverse(BiTree T,Status(* Visit)(TElemType e)){
83 InitStack(S); p=T;
84 while(p||!StackEmpty(S)){
85 if(p){ //根指针进栈，遍历左子树
86 Push(S,p);
87 p = p->lchild;
88 }
89 else{ //根指针退栈访问根结点，遍历右子树
90 Pop(S,p);
91 if(!Visit(p->data)) return ERROR;
92 p = p->rchild;
93 }
94 }
95 return OK;
96 }
97
98 int main(){
99
100
101 return 0;
102 }
103
104
105 /********************补充**********************/
106 //递归形式
107 //先序
108 void PreOrder(BiTree *bt){
109 if(bt){
110 visit(bt->data);
111 PreOrder(bt->lchild);
112 PreOrder(bt->rchild);
113 }
114 }
115 //中序
116 void InOrder(BiTree *bt){
117 if(bt){
118 InOrder(bt->lchild);
119 visit(bt->data);
120 InOrder(bt->rchild);
121 }
122 }
123 //后序
124 void PostOrder(BiTree *bt){
125 if(bt){
126 PostOrder(bt->lchild);
127 PostOrder(bt->rchild);
128 visit(bt->data);
129 }
130 }
131
132 //层次遍历
133 /*
134 利用一个队列，将根入队，以后队列不空取队头p
135 p不空，访问，再将右子树入队。
136 */
137 //queue
138 void LevelOrder(BiTree *bt){
139 InitQueue(Q); //初始化
140 EnQueue(Q,bt); //根入队
141 while(!QueueEmpty(Q)){ //队列不为空
142 DeQueue(Q,p);
143 if(p!= NULL){
144 visit(p->lchild);
145 //左右子树入队
146 EnQueue(Q,p->lchild);
147 EnQueue(Q,p->rchild);
148 }
149 }
150 }
151 //队列表现为q[]+front+rear
152 void LevelOrder(BiTree *bt){
153 const int maxn = 1024;
154 BiTree q[maxn];
155 int front,rear;
156 //初始化为空
157 front = rear = 0;
158 //根入队列
159 q[rear] = bt; rear = (rear+1) % maxn;
160 //队列不为空
161 while(front != rear){
162 p = q[front]; front = (front+1) % maxn;
163 if(p){
164 visit(p->data);
165 //左右子树入队列
166 q[rear] = p->lchild; rear = (rear+1) % maxn;
167 q[rear] = p->rchild; rear = (rear+1) % maxn;
168 }
169
170 }
171 }
172
173
174 //非递归
175 //中序
176 //沿着左子树向下移动，同时入栈保存。到达空子树就退栈访问结点，然后移动到右子树
177 void InOrder(BiTree *bt){
178 InitStack(S);
179 p = bt;
180 while(p || !StackEmpty(S)){
181 if(p){
182 Push(S,p);
183 p = p->lchild;
184 }
185 else{
186 Pop(S,p);
187 visit(p);
188 p = p->rchild;
189 }
190 }
191 }
192 //先序
193 void PreOrder(BiTree *bt){
194 InitStack(S);
195 p = bt;
196 while(p || !StackEmpty(S)){
197 if(p){
198 visit(p); //先序访问结点的位置
199 Push(S,p);
200 p = p->lchild;
201 }
202 else{
203 Pop(S,p);
204 p = p->rchild;
205 }
206 }
207 }
208 //后序
209 //分别从左右子树返回根结点，只有从右子树的时候才访问根结点，所以增加一个栈标记到达结点的次序。
210 void PostOrder(BiTree *bt){
211 InitStack(S);InitStack(tag);
212 p = bt;
213 while(p||!StackEmpty(S)){
214 if(p){
215 Push(S,p); Push(tag,1); //第一次入栈
216 p = p->lchild;
217 }
218 else{
219 Pop(S,p); Pop(tag,f);
220 if(f == 1){
221 //左子树返回，二次入栈，p转右子树
222 Push(S,p); Push(tag,2);
223 p = p->rchild;
224 }
225 else{
226 //右子树返回，访问根结点，p转上层
227 visit(p);
228 p = NULL; //下一步退栈
229 }
230 }
231 }
232 }
233
234
235
236 /**************遍历二叉树的应用****************/
237
238 //二叉树结点的个数
239 int NodeCount(BiTree *bt){
240 if(bt == NULL) return 0;
241 else return 1+NodeCount(bt->lchild)+NodeCount(bt->rchild);
242 }
243
244 //二叉树叶子结点的个数
245 int LeafCount(BiTree *bt){
246 if(bt == NULL) return 0;
247 else if(bt->lchild == NULL && bt->rchild == NULL) return 1;
248 else return LeafCount(bt->lchild) + LeafCount(bt->rchild);
249 }
250
251 //二叉树的深度
252 int Depth(BiTree *bt){
253 if(bt == NULL ) return 0;
254 else return 1+max(Depth(bt->lchild),Depth(bt->rchild));
255 }
1 #include<bits/stdc++.h>
2 using namespace std;
3 #define INF 0xfffff
4 #define MAX_N 20
5 typedef enum {DG,DN,UDG,UDN} GraphKind; //{有向图，有向网，无向图，无向网}
6 bool visited[MAX_N];
7
8 /*基本操作
9
10 CreateGraph(&G,V,VR); //构造图。V是顶点集，VR是弧
11 DestroyGraph(&G); //销毁图
12 LocateVex(G,u); //返回顶点u的位置
13 GetVex(G,v); //返回v的值
14 PutVex(&G,v,value); //对v赋值value
15 FirstAdjVex(G,v); //返回v的第一个邻接顶点
16 NextAdjVex(G,v,w); //返回v的下一个邻接顶点（相对于w）
17 InsertVex(&G,v); //在图中加入顶点
18 DeleteArc(&G,v); //删除v及v相关的弧
19 InsertVex(&G,v,w); //加入v,w的弧
20 DeleteVex(&G,v,w); //在G中删除弧v,w
21 DFSTraverse(G,Visit()); //DFS
22 BFSTraverse(G,Visit()); //BFS
23
24 */
25
26
27 typedef struct ArcCell{
28 VRType adj; //顶点关系类型。无权图0/1
29 InfoType *info; //该弧相关信息的指针
30
31 }ArcCell,AdjMatrix[MAX_N][MAX_N];
32
33 typedef struct{
34 VertexType vexs[MAX_N]; //顶点向量
35 AdjMatrix arcs; //邻接矩阵
36 int vexnum,arcnum; //图的当前顶点数和弧数
37 GraphKind kind; //图的种类
38 }MGraph;
39
40 //邻接表
41 typedef struct ArcNode{
42 int adjvex; //弧所指向顶点的位置
43 struct ArcNode *nextarc; //指向下一条弧的指针
44 InfoType *info; //该弧的相关信息的指针
45 }ArcNode;
46
47 typedef struct VNode{
48 VertexType data; //顶点信息
49 ArcNode *firstarc; //指向第一条依附该顶点的弧的指针
50 }VNode,AdjList[MAX_N];
51 typedef struct{
52 AdjList Verices;
53 int vexnum,arcnum; //当前顶点数和弧数
54 int kind; //图种类标志
55 }ALGraph;
56
57
58 //DFS
59 Status (*VisitFunc)(int v);
60 void DFSTraverse(Graph G,Status (*Visit)(int v)){
61 VisitFunc = Visit; //使用全局变量
62 for(v = 0; v < G.vexnum; v++) visited[v] = FALSE; //访问标志数组初始化
63 for(v = 0; v < G.vexnum; v++){
64 if(!visited[v]) DFS(G,v); //对尚未访问的邻接点调用DFS
65 }
66 }
67
68 void DFS(Graph G, int v){
69 //从第v个结点出发访问
70 visited[v] = TRUE; VisitFunc(v); //访问第v个顶点
71 for(w = FirstAdjVex(G,v); w>=0 ; w = NextAdjVex(G,v,w))
72 if(!visited[w]) DFS(G,w); //对v尚未访问的顶点w递归调用DFS
73 }
74
75 //BFS
76 void BFSTraverse(Graph G,Status (*Visit)(int v)){
77 for(v = 0 ; v < G.vexnum; v++) visited[v] = FALSE;
78 InitQueue(Q);
79 for(v = 0; v < G.vexnum; v++){
80 if(!visited[v]){ //v尚未访问
81 visited[v] = TRUE; Visit(v);
82 EnQueue(Q,v); //v入队
83 while(!QueueEmpty(Q)){
84 DeQueue(Q,u); //队头出队并置为u
85 for(w = FirstAdjVex(G,u);w >= 0; w = NextAdjVex(G,u,w)){
86 if(!visited[w] = TRUE){ //w为u的尚未访问过的邻接顶点
87 visited[w] = TRUE; Visit(w);
88 EnQueue(Q,w);
89 }
90 }
91 }
92 }
93 }
94 }
95
96
97 //Prim
98 Void Prim(MGraph G, VertexType u){
99 /*
100 struct{
101 VertexTypeadjvex;
102 VRType lowcost;
103 }closedge[MAX_N];
104 */
105 k = LocateVex(G,u);
106 //辅助数组初始化
107 for(j = 0 ; j < G.vexnum; i++){
108 if(j != k ) closedge[j] = {u,G.arcs[k][j].adj};
109 }
110 closedge[k].lowcost = 0; //初始U={u}
111 for(i = 1; i < G.vexnum; i++){ //选择其余G.vexnum-1个结点
112 k = minimum(closedge); //求出T的下一个结点，k
113 /*此时
114 closedge[k].lowcost =
115 min{closedge[vi].lowcost|closedge[vi].lowcost>0}
116 */
117
118 printf(closedge[k].adjvex,G.vexs[k]); //输出生成树的边
119 closedge[k].lowcost = 0; //第k个顶点入U
120 for(j = 0; j < G.vexnum; j++){
121 if(G.arcs[k][j].adj < closedge[j].lowcost){//新顶点入U后重新选择最小边
122 closedge[j] = {G.vexs[k],G.arcs[k][j].adj};
123 }
124 }
125 }
126 }
127
128
129 int main(){
130
131 return 0;
132 }
1 #include<bits/stdc++.h>
2 using namespace std;
3
4 typedef float KeyType;
5 typedef int KeyType;
6 typedef char *KeyType;
7
8 #define EQ(a,b) (a == b)
9 #define LT(a,b) (a < b)
10 #define LQ(a,b) (a <= b)
11
12
13 typedef struct{
14 KeyType key; //关键字
15 ...... //其他
16
17 }SElemType；
18
19
20 /*基本操作
21 Create(&ST,n); //构造一个含n个数据元素的集合ST
22 Destroy(&ST); //销毁ST
23 Search(ST,key); //查找和key相等的元素，并返回位置
24 Traverse(ST,Visit); //按照某种次序对每个元素调用函数，仅一次
25 */
26
27
28 //顺序
29 typedef struct {
30 TElemType *elem; //数据元素存储空间基址
31 int length; //表长度
32 }SSTable;
33
34 //顺序查找
35 int Search_Seq(SSTable ST,KeyType key){
36 ST.elem[0].key = key; //哨兵
37 for(i = ST.length; !EQ(ST.elem[i].key,key); --i) //从后往前找
38 return i;
39
40 }
41
42 //折半查找
43 int Search_Bin(SSTable ST,KeyType key){
44 low = 1; high = ST.length; //置区间初值
45 while(low <= high){
46 mid = (low + high) / 2;
47 if(EQ(key,ST.elem[mid].key)) return mid; //找到
48 else if(LT(key,ST.elem[mid].key)) high = mid - 1; // 前半区间
49 else low = mid + 1; //后半区间
50
51 }
52 return 0;
53 }
54
55 /*****************动态查找*****************/
56 /*基本操作
57
58 InitDSTable(&DT); //创造空的动态表
59 DestroyDSTable(&DT); //销毁动态表
60 SearchDSTable(DT,key); //查找和key相等的数据元素返回位置
61 InsertDSTable(&DT,e); //不存在和e.key相等的元素的情况下插入e
62 DeleteDSTable(&DT,e); //若存在和e.key相等的元素，删除。
63 TraverseDSTable(DT,Visit()); //对DT每个结点只访问一次
64
65 */
66
67
68 //二叉排序树
69 //查找
70 BiTree SearchBST(BiTree T, KeyType key){
71 //根指针T所指二叉排序树中递归的查找某关键字等于key的数据元素。
72 //查找成功，返回指向该数据元素结点的指针。
73 if(!T || EQ(key,T->data.key)) return T;
74 else if(LT(key,T->data.key)) return (SearchBST(T->lchild,key));
75 else return (SearchBST(T->rchild,key));
76 }
77
78 //查找便于插入版本
79 Status SearchBST(BiTree T,KeyType key,BiTree f,BiTree &p){
80 if(!T) {p = f; return FALSE;}
81 else if(EQ(key,T->data.key)) {p = T; return TRUE;}
82 else if(LT(key,T->data.key)) return SearchBST(T->lchild,key,T,p);
83 else return SearchBST(T->rchild,key,T,p);
84 }
85 //插入
86 Status InsertBST(BiTree &T,ElemType e){
87 if(!SearchBST(T,e.key,NULL,p)){
88 s = (BiTree) malloc(sizeof(BiTNode));
89 s->data = e; s->lchild = s->rchild = NULL;
90 if(!p) T = s; //被插结点为新的根结点。
91 else if LT(e.key,p->data.key) p->rchild = NULL; //被插结点为左孩子
92 else p->rchild = s; //被插结点为右孩子
93 return TRUE;
94 }
95 else return FALSE;
96 }
97
98 //删除
99 Status DeleteBST(BiTree &T,KeyType key){
100 if(!T) return FALSE;
101 else{
102 if(EQ(key,T->data.key)) return Delete(T);
103 else if(LT(key,T->data.key)) return DeleteBST(T->lchild,key);
104 else return DeleteBST(T->rchild,key);
105 }
106 }
107 Status Delete(BiTree &p){
108 //重连左/右子树
109 //右子树空就重连左子树
110 if(!p->rchild){
111 q = p;
112 p = p->lchild;
113 free(q);
114 }
115 else if(!p->lchild){ //重连右子树
116 q = p;
117 p = p->rchild;
118 free(q);
119 }
120 else{ //左右子树都不空
121 q = p; s = p->lchild;
122 while (s->rchild){q = s; s = s->rchild;} //转左，向右到尽头
123 p->data = s->data; //s指向被删结点的前驱
124 if(q != p) q->rchild = s->lchild; //重连右子树
125 else q->lchild = s->lchild; //重连左子树
126 delete s;
127 }
128 return TRUE;
129 }
130
131 int main(){
132
133
134 return 0;
135 }
1 #include<bits/stdc++.h>
2 using namespace std;
3
4 #define maxn 20
5 typedef int KeyType;
6
7 typedef struct {
8 KeyType key; //关键字项
9 InfoType otherinfo; //其他数据项
10 }RedType;
11
12 typedef struct {
13 RedType r[maxn+1];
14 int length;
15 }SqList;
16
17 //LT(a,b) <=> a<b
18
19 //直接插入排序
20 void BinInsert(SqList &L){
21 for(i = 2 ; i <= L.length; i++){
22 if(LT(L.r[i].key, L.r[i-1].key)){ //<,L.r[i]插入有序子表
23 L.r[0] = L.r[i]; //复制为哨兵
24 L.r[i] = L.r[i-1];
25 for(j = i-2; LT(L.r[0].key,L.r[j].key); --j){
26 L.r[j+1] = L.r[j]; //记录后移
27 }
28 L.r[j+1] = L.r[0]; //插入到正确位置
29 }
30 }
31 }
32
33 //折半插入排序
34 void BInsertSort(SqList &L){
35 for(i = 2; i <= L.length ;i++){
36 L.r[0] = L.r[i]; //暂存到L.r[0]
37 low = 1; high = i-1;
38 while(low <= high){ //在low-high中折半查找有序
39 m = (low + high)/2; //折半
40 if(LT(L.r[0].key,L.r[m].key)) high = m-1; //插入点在低半区
41 else low = m+1; //插入点在高半区
42 }
43 for(j = i-1 ;j >= high+1 ; j--) L.r[j+1] = L.r[j]; //记录后移
44
45 L.r[high+1] = L.r[0]; //插入
46 }
47 }
48
49 //希尔排序
50 void ShellInsert(SqList &L,int dk){
51 for(i = dk+1 ; i <= L.length; i++){
52 if(LT(L.r[i].key, L.r[i-dk].key)){ //将L.r[i]插入有序子表
53 L.r[0] = L.r[i]; //暂存在L.r[0]
54 for(j = i-dk ; j > 0 && LT(L.r[0].key,L.r[j].key); j -= dk){
55 L.r[j+dk] = L.r[j]; //记录后移，查找插入位置
56 }
57 L.r[j+dk] = L.r[0];
58 }
59 }
60 }
61 void ShellSort(SqList &L,int dita[],int t){
62 for(k = 0; k < t; k++){
63 ShellInsert(L.dlta[k]); //一趟增量为dlta[k]的插入排序
64 }
65 }
66
67 //快速排序
68 int Partition(SqList &L,int low,int high){
69 L.r[0] = L.r[low]; //用子表的第一个记录作枢轴
70 pivotkey = L.r[low].key; //枢轴记录关键字
71 while(low < high){ //从表的两端交替向中间扫描
72 while(low < high && (L.r[high].key >= pivotkey) ) --high;
73 L.r[low] = L.r[high]; //小的移到低端
74 while(low < high && (L.r[high].key <= pivotkey) ) ++low;
75 L.r[high] = L.r[low]; //大的移到高端
76 }
77 L.r[low] = L.r[0]; //枢轴记录到位
78 return low; //返回枢轴位置
79 }
80 void QSort(SqList &L, int low ,int high){
81 if(low < high){
82 pivotloc = Partition(L,low,high); //分成两个子表
83 QSort(L,low,pivotloc-1); //低子表递归排序
84 QSort(L,pivotloc+1,high); //高子表递归排序
85 }
86 }
87 void QuickSort(SqList &L){
88 QSort(L,1,length);
89 }
90
91 //简单选择排序
92 void SelectSort(SqList &L){
93 for(i = 1; i < L.length ;i++){
94 j = SelectMinKey(L,i);
95 if(i != j) swap(L.r[i],L.r[j]);
96 }
97 }
98
99 //归并排序
100 void Merge(T a[],int low,int mid,int high){
101 i = low;
102 j = mid+1; k = low;
103 while(i <= mid && j <= high){
104 if(a[i] <= a[j]){
105 b[k] = a[i];
106 i++;
107 }
108 else{
109 b[k] = a[j];
110 j++;
111 }
112 k++;
113 }
114 while(i <= mid) b[k++] = a[i++];
115 while(j <= high) b[k++] = a[j++];
116 a[low...high] = b[low...high];
117 }
118 void MergeSort(T a[],int low ,int high){
119 if(low >= high) return;
120 else{
121 int mid = (low+high)/2;
122 MergeSort(a,low,mid);
123 MergeSort(a,mid+1,high);
124 Merge(a,low,mid,high);
125 }
126 }
127
128
129 int main(){
130
131 return 0;
132 }
1 #include<bits/stdc++.h>
2 using namespace std;
3 #define MaxSize 255
4
5 typedef unsigned char SString[MaxSize + 1];
6 /*基本操作
7 StrAssign(&T,chars); //生成一个值等于chars的串T
8 StrCopy(&T,S); //由串S复制得T
9 StrEmpty(S); //判断串是否为空
10 StrCompare(S,T); //S > T 返回>0
11 StrLength(S); //返回S的元素个数，串的长度
12 ClearString(&S); //清空S
13 Concat(&T,S1,S2); //返回由S1，S2连接而成的新串
14 SubString(&Sub,S,pos,len); //Sub返回串的第pos个字符起长度为len的子串
15 Index(S,T,pos); //返回T在S中第pos个字符后第一次出现的位置
16 Replace(&S,T,V); //用V替换S中所有与T相等的不重叠子串
17 StrInsert(&S,pos,T); //在S的第pos个字符前插入串T
18 StrDelete(&S,pos,len); //删除第pos个字符开始长度为len的子串
19 DestroyString(&S); //串被销毁
20
21 */
22
23
24 //模式匹配
25 int Index(SString S,SString T, int pos){
26 i = pos; j = 1;
27 while(i <= S[0] && j <= T[0]){
28 if(S[i] == S[T]){
29 ++i; ++j; //继续比较后继字符
30 }
31 else{
32 i = i-j+2; j = 1; //指针后退重新匹配
33 }
34 }
35 if(j > T[0]) return i-T[0];
36 else return 0;
37 }
38
39 //KMP
40 int Index_KMP(SString S,SString T,int pos){
41 i = pos; j = 1;
42 while(i <= S[0] && j <= T[0]){
43 if(j == 0 || S[i] == T[j]){
44 ++i; ++j; //继续比较后继字符
45 }
46 else j = next[j]; //模式串向右移动
47 }
48 if(j > T[0]) return i-T[0]; //匹配成功
49 else return 0;
50 }
51
52 //next数组
53 void get_next(SString T,int next[]){
54 i = 1; next[1] = 0; j = 0;
55 while(i < T[0]){
56 if(j == 0 || T[i] == T[j]){
57 ++i; ++j; next[i] = j;
58 }
59 else j = next[j];
60 }
61 }
62
63 //nextval
64 void get_nextval(SString T ,int nextval[]){
65 i = 1;nextval[1] = 0; j = 0;
66 while(i < T[0]){
67 if(j == 0 || T[i] == T[j]){
68 ++i; ++j;
69 if(T[i] != T[j]) nextval[i] = j;
70 else nextval[i] = nextval[j];
71 }
72 else j = nextval[j];
73 }
74 }
75 int main(){
76
77
78 return 0;
79 }
来源：https://www.cnblogs.com/Asumi/p/12161756.html