数据结构基本代码汇总

文章目录

一、线性表
二、栈
三、队列
四、串
五、树与二叉树
六、图
七、查找
八、排序

一、线性表

1.顺序表的定义
#define Maxsize 50
typedef struct{ElemType data[Maxsize];int length;
}SqList;动态分配下的顺序表（不常考）
#define InitSize 100
typedef struct{ElemType *data;int MaxSize,length;
}SqList;
L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize); 2.顺序表的基本操作//在第i个位置插入
bool ListInsert(SqList &L,int i,ElemType e){if(i<1||i>L.length+1) return false;if(L.length>=Maxsize) return false;for(int j=L.length;j>=i;j--){L.data[j]=L.data[j-1];}L.data[i-1]=e;L.length++;return true;
}//在第i个位置删除
bool ListDelete(SqList &L,int i,ElemType &e){if(i<1||i>L.length) return false;for(int j=i-1;j<L.length;j++){L.data[j]=L.data[j+1];}L.length--;return true;
}//按值查找（顺序查找）
int LocateElem(Sqlist L,ElemType e){for(int i=0;i<L.length;i++){if(L.data[i]==e){return i+1;}}return 0;
}

2.线性表的链式表示

1.单链表定义
typedef struct LinkNode{ElemType data;struct LinkNode *next;
}LinkNode,*LinkList;

单链表的基本操作

1.头插法建立单链表
LinkList Insert_head(LinkList &L){LNode *s;int x;L=(LinkList)malloc(sizeof(LinkNode));scanf("%d",&x);while(x!=9999){s=(LinkNode*)malloc(sizeof(LinkNode));s->data=x;s->next=L->next;L->next=s;scanf("%d",&x);}return L;
}2.尾插法建立单链表
LinkList Insert_tail(LinkList &L){LinkNode *s,*r;int x;L=(LinkList)malloc(sizeof(LinkNode));r=L;scanf("%d",&x);while(x!=9999){s=(LinkNode*)malloc(sizeof(LinkNode));s->data=x;r->next=s;r=s;scanf("%d",&x);}r->next=NULL;return L;
}3.按序号查找节点
LinkNode *Findvalue(LinkList L,int i){int j=1;LinkNode *p=L->next;if(i==0) return L;if(i<1) return NULL;while(p&&j<i){p=p->next;j++;}return p;
}4.按值查找节点
LinkNode *Getvalue(LinkList L,ElemType e){LinkNode *p=L->next;while(p&&p->data!=e){p=p->next;}return p;
}5.插入节点（插入值为x的节点到第i个位置）
void Insertvalue(LinkList &L,int i,ElemType e){LinkNode *s=(LinkNode*)malloc(sizeof(LinkNode));s->data=e;int j=1;LinkNode *p=L->next;while(p&&j<i-1){p=p->next;j++;}s->next=p->next;p->next=s;return ;
}6.删除第i个节点
void Deletei(LinkList &L,int i){int j=1;LinkNode *p=L->next;while(p&&j<i-1){p=p->next;j++;}LinkNode *s=p->next;p->next=s->next;free(s);return ;
}

双链表

1.定义
typedef struct DNode{ElemType data;struct DNode *prior,*next;
}DNode,*DLinkList;2.插入s->next=p->next;p->next->prior=s;p->next=s;s->prior=p;3.删除
p->next=s->next;
s->next->prior=p;
free(s);

静态链表

1.定义
#define MaxSize 50
typedef struct{ElemType data;int next;
}SLinkList[MaxSize];

二、栈

顺序栈（大题中常用此物理结构）

1.定义
#define MaxSize 50
typedef struct{ElemType data[MaxSize];int top;
}SqStack;2.初始化
void InitStack(SqStack &S){S.top=-1;
}3.判断栈为空
bool StackEmpty(SqStack S){if(S.top==-1)return true;elsereturn false;
}4.进栈
bool Push(SqStack &S,ElemType x){if(S.top==MaxSize-1) return false;S.data[++S.top]=x;return true;
}5.出栈
bool Pop(SqStack &S,ElemType &x){if(S.top==-1) return false;x=S.data[S.top--];return true;
}6.读栈顶元素
bool GetTop(SqStack &S,ElemType &x){if(S.top==-1) return false;x=S.data[S.top];return true;
}

链式栈

1.定义
typedef struct LinkNode{ElemType data;struct LinkNode *next;
}*LiStack;

三、队列

顺序循环队列

1.定义
#define MaxSize 60
typedef struct{ElemType data[MaxSize];int front,rear;
}SqQueue;2.初始化
void InitQueue(SqQueue &Q){Q.front=Q.rear=0;
}3，判断队空
bool QueueEmpty(SqQueue Q){if(Q.front==Q.rear)return true;elsereturn false;
}4.入队
bool EnQueue(SqQueue &Q,ElemType x){if((Q.rear+1)%MaxSize==Q.front){return false;}Q.data[Q.rear]=x;Q.rear=(Q.rear+1)%MaxSize;return true;
}5.出队
bool DeQueue(SqQueue &Q,ElemType &x){if(Q.rear==Q.front){return false;}x=Q.data[Q.front];Q.front=(Q.front+1)%MaxSize;return true;
}

链式队列

1.定义
typedef struct LinkNode{ElemType data;struct LinkNode *next;
}LinkNode;
typedef struct{LinkNode *front,*rear;
}LinkQueue;2.初始化
void InitQueue(LinkQueue &Q){Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));Q.front->next=NULL;
}3.判断队空
bool isEmpty(LinkQueue Q){if(Q.front==Q.rear)return true;elsereturn false;
}4.入队（链队无须判断队满）
void EnQueue(LinkQueue &Q,ElemType x){LinkNode *s=(LinkNode*)malloc(sizeof(LinkNode));s->data=x;s->next=NULL;Q.rear->next=s;Q.rear=s;
}5.出队
bool DeQueue(LinkQueue &Q,ElemType &x){if(Q.rear==Q.front){return false;}LinkNode *p=Q.front->next;x=p->data;Q.front->next=p->next;if(Q.rear==p){Q.rear=Q.front;}free(p);return true;
}

四、串

顺序存储

#define MLen 255
typedef struct{char ch[MLen];int length;
}SString;

堆分配存储（动态分配）

typedef struct{char *ch;int length;
}HString;

简单的模式匹配算法

int index(SString s,SString t){int i=1,j=1;while(i<=s.length&&j<=t.length){if(s.ch[i]==t.ch[j]){i++,j++;}else{i=i-j+2;j=1;}}if(j>t.length){return i-t.length;}else{return 0;}
}

KMP算法

void get_next(String s,int next[]){int i=1,j=0;next[1]=0;while(i<t.length){if(j==0||t.ch[i]==t.ch[j]){i++,j++;next[i]=j;}else{j=next[j];}}
}
int index_kmp(String s,String t,int next[]){int i=1,j=1;while(i<=s.length&&j<=t.length){if(j==0||s.ch[i]==t.ch[j]){j++,i++;}else{j=next[j];}if(j>t.length){return i-t.length;}elsereturn 0;}
}//优化
void get_nextval(String t,int nextval[]){int i=1,j=0;nextval[1]=0;while(i<t.length){if(j==0||t.ch[i]==t.ch[j]){i++,j++;if(t.ch[i]!=t.ch[j]) nextval[i]=j;else nextval[i]=nextval[j];}else{j=nextval[j];}}
}

五、树与二叉树

二叉树

1.定义
typedef struct BiNode{int data;struct BiNode *lchild,*rchild;
}BiNode,*BiTree; 2.先序遍历
void PreOrder(BiTree T){if(T!=NULL){visit(T);PreOrder(T->lchild);PreOrder(T->rchild);}
}3.1先序遍历的非递归算法（栈）
void PreOrder_f(BiTree T){InitStack(S);BiTree p=T;while(p||!isEmpty(S)){if(p){visit(p);Push(S,p);p=p->lchild;}else{Pop(S,p);p=p->rchild;}}
}3.2中序遍历的非递归算法//与先序类似
void InOrder(BiTree T){InitStack(S);BiTree p=T;while(p||!IsEmpty(S)){if(p){Push(S,p);p=p->lchild;}else{Pop(S,p);visit(p);p=p->rchild;}}
}3.3后序遍历的非递归算法（难）
void PostOrder_f(BiTree T){InitStack(S);BiTree p=T;BiNode *r=NULL;while(p||!isEmpty(S)){if(p){Push(S,p);p=p->lchild;}else{GetTop(S,p);if(p->rchild&&p->rchild!=r){p=p->rchild;}else{Pop(S,p);visit(p);r=p;p=NULL;}   }}
}4.层次遍历（队列）
void LevelOrder(BiTree T){InitQueue(Q);BiTree p;EnQueue(Q,T);while(!IsEmpty(Q)){DeQueue(Q,p);visit(p);if(p->lchild!=NULL){EnQueue(Q,p->lchild);}if(p->rchild!=NULL){EnQueue(Q,p->rchild);}}
}

线索二叉树

1.定义
typedef struct ThreadNode{int data;int ltag,rtag;struct ThreadNode *lchild,*rchild;
}ThreadNode,*ThreadTree;2.中序线索化建线索二叉树
void InThread(ThreadTree &p,ThreadTree &pre){if(p!=NULL){InThread(p->lchild,pre);if(p->lchild==NULL){p->lchild=pre;p->ltag=1;}if(pre!=NULL&&pre->rchild==NULL){pre->rchild=p;pre->rtag=1;}pre=p;InThread(p->rchild,pre);}
}
void CreateInThread(ThreadTree T){ThreadTree pre=NULL;if(T!=NULL){InThread(T,pre);pre->rchild=NULL;pre->rtag=1;}
}3.先序线索化建线索二叉树（防转圈）
void PreThread(ThreadTree &p,ThreadTree &pre){if(p!=NULL){if(p->lchild==NULL){p->lchild=pre;p->ltag=1;}if(pre!=NULL&&pre->rchild==NULL){pre->rchild=p;pre->rtag=1;}pre=p;if(p->ltag==0)//防转圈，确保左子树还没有被线索化PreThread(p->lchild,pre);PreThread(p->rchild,pre);}
}
void CreatePreThread(ThreadTree T){ThreadTree pre=NULL;if(T!=NULL){PreThread(T,pre);pre->rchild=NULL;pre->rtag=1;}
}4.后序线索化建线索二叉树
void CreatePostThread(ThreadTree T){ThreadTree pre=NULL;if(T!=NULL){PostThread(T,pre);pre->rchild=NULL;pre->rtag=1;}
}
void PostThread(ThreadTree &p,ThreadTree &pre){if(p!=NULL){PostThread(p->lchild,pre);PostThread(p->rchild,pre);if(p->lchild==NULL){p->lchild=pre;p->ltag=1;}if(pre!=NULL&&pre->rchild==NULL){pre->rchild=p;pre->rtag=1;}pre=p;}
}5.中序线索二叉树的遍历
（1）求中序序列下第一个结点
ThreadNode *Firstnode(ThreadNode *p){while(p->ltag==0) p=p->lchild;return p;
}
（2）求结点p的后继
ThreadNode *Nextnode(ThreadNode *p){if(p->rtag==1) return p->rchild;return Firstnode(p->rchild);
}
（3）中序遍历中序线索二叉树
void Inorder(ThreadNode *T){for(ThreadNode *p=Firstnode(p);p!=NULL;p=Nextnode(p))visit(p);
}

树

1.定义
（1）双亲表示法
#define MAX_TREE 100
typedef struct{ElemType data;int parent;
}PTNode;
typedef struct{PTNode nodes[MAX_TREE];int n;
}PTree;（2）孩子兄弟表示法
typedef struct CSNode{ElemType data;struct CSNode *firstchild,*nextsibling;
}CSNode,*CSTree;（3）孩子表示法（将每个结点的孩子都用单链表链接起来形成一个线性结构，n个结点有n个孩子链表）

并查集

1.定义
#define SIZE 100
int UFSets[SIZE];2.初始化
void Init(int S[]){for(int i=0;i<size;i++)S[i]=-1;
}3.合并root1和root2到一个分支上
void Union(int S[],int root1,int root2){S[root2]=root1;
}4.找x的祖先（根节点）
int Find(int S[],int x){while(S[x]>0){x=S[x];}return x;
}

六、图

邻接矩阵

1.定义
#define MaxNode 100
typedef char VerType;
typedef int EdgeType;
typedef struct{EdgeType Edge[MaxNode][MaxNode];VerType Vex[MaxNode];int vernum,edgenum;
}MGraph;

邻接表

1.定义
typedef struct ALGraph{AdjList v;//表示一个顶点表数组int vexnum,arcnum;
}ALGraph;
typedef struct VNode{//顶点表数组 char data;//每个节点的名字 ArcNode *first;
}VNode,AdjList[MaxSize];
typedef struct ArcNode{int adjnum;//弧所指向的结点的编号（与顶点表数组对应） struct ArcNode *next;
}ArcNode;

从图的邻接表表示转换成邻接矩阵

void Convert(ALGraph G1,MGraph &G2){G2.edgenum=G1.arcnum;G2.vexnum=G1.vexnum;for(int i=0;i<G1.vexnum;i++){//初始化G2for(int j=0;j<G1.vexnum;j++){G2.Edge[i][j]=0;}}for(int i=0;i<G1.vexnum;i++){ArcNode *p=G1.vertices[i].first;while(p){int j=p->adjnum;G2.Edge[i][j]=1;p=p->next;}}
}

从图的邻接矩阵转化为邻接表

void convert(MGraph G1,ALGraph &G2){G2.arcnum=G1.edgenum;G2.vexnum=G1.vexnum;for(int i=0;i<G1.vexnum;i++){G2.vertices[i].first=NULL;}for(int i=0;i<G1.vexnum;i++){for(int j=0;j<G1.vexnum;j++){if(G1.Edge[i][j]){ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));p->adjnum=j;p->next=G2.vertices[i].first;G2.vertices[i].first=p;}}}
}

图的基本操作

1.NextNeighbor（MGraph &G,int x,int y）
//邻接矩阵
#define maxWeight 0x3f3f3f3f
int NextNeighbor(MGraph &G,int x,int y){if(x!=-1&&y!=-1){for(int col=y+1;col<G.vexnum;col++){if(G.Edge[x][col]>0&&G.Edge[x][col]<maxWeight)return col;}}return -1;
}//邻接表
int NextNeighbor(ALGraph &G,int x,int y){if(x!=-1){ArcNode *p=G.vertices[x].first;while(p!=NULL&&p->data!=y)p=p->next;if(p!=NULL&&p->next!=NULL)return p->next->data;}return -1;
}

广度优先搜索BFS（队列实现）

int vis[MaxSize];
void BFSOrder(Graph G){for(int i=0;i<G.vexnum;i++){vis[i]=0;}InitQueue(Q);for(int i=0;i<G.vexnum;i++){//预防非连通图的情况if(!vis[i])BFS(G,i);}
}
void BFS(Graph G,int i){vis[i]=1;EnQueue(Q,i);while(!isEmpty(Q)){DeQueue(Q,v);for(w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w)){if(!vis[w]){vis[w]=1;EnQueue(Q,w);}}}
}

BFS求单源最短路（无权值）

void BFS_MIN(Graph G,int u){//求u到图中其余顶点的最短路径 for(int i=0;i<G.vexnum;i++){d[i]=-1;}vis[u]=1;d[u]=0;EnQueue(Q,u);while(!isEmpty(Q)){DeQueue(Q,u);for(w=FirstNeighbor(Q,u);w>=0;w=NextNeighbor(Q,u,w)){if(!vis[w]){vis[w]=1;d[w]=d[u]+1;//EnQueue(Q,w);}}}
}

深度优先搜索DFS

int vis[MaxSize];
void DFSOrder(Graph G){//和bfs一模一样for(int i=0;i<G.vexnum;i++){vis[i]=0;}for(int i=0;i<G.vexnum;i++){if(!vis[i]){DFS(G,i);}}
}
void DFS(Graph G,int v){vis[v]=1;for(w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w)){if(!vis[w]){DFS(G,w);//走一条中国特色社会主义道路}}
}

用dfs判断无向图是否是树

int vis[MaxSize];
bool pd_Tree(Graph G){int vnum=1,anum=0;for(int i=0;i<G.vexnum;i++){vis[i]=0;}DFS(G,0,vnum,anum);if(vnum==G.vexnum&&2*(vnum-1)=anum)return 1;else return 0;
}
void DFS(Graph G,int v,int &vnum,int &anum){vis[v]=1;for(w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w)){if(!vis[w]){vnum++;anum++;DFS(G,w,vnum,anum);}}
}

dfs的非递归算法（用栈实现，与bfs基本一样）

int vis[MaxSize];
void DFS_f(Graph G,int v){//从v结点开始遍历，前提是这个图是连通图 int w;InitStack(S);for(i=0;i<G.vexnum;i++){vis[i]=0;}Push(S,v);vis[v]=1;while(!isEmpty(S)){Pop(S,p);visit(p);for(w=FirstNeighbor(G,p);w>=0;w=NextNeighbor(G,p,w)){if(!vis[w]){Push(S,w);vis[w]=1;}}}
}

用dfs判断是否存在vi到vj的路径

int vis[MaxSize]={0};
void DFS(ALGraph G,int i,int j,bool &can_reach){if(i==j){can_reach=true;return;}vis[i]=1;for(int p=FirstNeighbor(G,i);p>=0;p=NextNeighbor(G,i,p)){if(!vis[p]&&!can_reach)DFS(G,p,j,can_reach);}
}

用bfs判断是否存在vi到vj的路径

int vis[MaxSize]={0};
int BFS(ALGraph G,int i,int j){InitQueue(Q);EnQueue(i);while(!isEmpty(Q)){DeQueue(Q,p);vis[p]=1;if(p==j) return 1;for(int w=FirstNeighbor(G,p);w>=0;w=NextNeighbor(G,p,w)){if(w==j) return 1;if(!vis[w]){vis[w]=1;EnQueue(Q,w);}}}return 0;
}

vi到vj所有简单路径

void FindPath(ALGraph &G,int u,int v,int path[],int d){d++;path[d]=u;vis[u]=1;if(u==v){print(path[]);}ArcNode *p;p=G->AdjList[u].firstarc;while(p){w=p->adjnum;if(!vis[w])FindPath(G,w,v,path,d);p=p->next;}vis[u]=0;
}

最小生成树

1.Prim算法
int getSum(MGraph &G,int *prims){int sum=0;for(int i=1;i<G.vexnum;i++){int min=39999;for(int j=0;j<i;j++){if(G.Edge[prims[j]][prims[i]]<min){min=G.Edge[prims[j]][prims[i]];}}sum+=min;}return sum;
}
void prim(MGraph &G,int start){//邻接矩阵实现 int prims[MaxSize];int lowCost[MaxSize];int min,k,index=0;     lowCost[start]=0;//自己到自己的距离为0 prims[index++]=start;for(int i=0;i<G.vexnum;i++){lowCost[i]=G.Edge[start][i];//将所有连接顶点的边的权值存入 }for(int i=0;i<G.vexnum;i++){if(start==i) continue;min=39999;for(int j=0;j<G.vexnum;j++){if(lowCost[j]!=0&&lowCost[j]<min){min=lowCost[j];k=j;}}prims[index++]=k;lowCost[k]=0;//将当前选中的顶点置为已访问 for(int j=0;j<G.vexnum;j++){if(lowCost[j]&&G.Edge[k][j]<lowCost[j]){lowCost[j]=G.Edge[k][j];}}printf("%d",getSum(G,prims));for(int i=0;i<G.vexnum;i++){printf("%c",G.Vex[prims[i]]);}}
}

拓扑排序

bool TopoSort(Graph G){InitStack(S);for(int i=0;i<G.vexnum;i++){if(indegree[i]==0)Push(S,i);}int count=0;while(!isEmpty(S)){Pop(S,i);print[count++]=i;for(p=G.adjList[i].firstarc;p;p=p->next){v=p->adjnum;if(!(--indegree[v]))Push(S,v);}}if(count<G.vexnum) return false;else return true;
}

DFS实现拓扑排序

int vis[MaxSize]={0};
void DFStopo(Graph G){time=0;for(v=0;v<G.vexnum;v++){if(!vis[v])DFS(G,v);}
}
void DFS(Graph G,int v){vis[v]=1;visit(v);for(w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w)){if(!vis[w]){DFS(G,w);}}time=time+1;finishTime[v]=time;
}

七、查找

顺序查找

typedef struct{Elemtype elem[MaxSize];int len;
}STable;
int search(STable ST,Elemtype key){ST.elem[0]=key;//哨兵int i;for(i=ST.len;ST.elem[i]!=key;i--);return i;
}

折半查找

int binary_search(STable L,Elemtype key){int low=0,high=L.len-1,mid;while(low<=high){mid=(low+high)/2;if(L.elem[mid]==key)return mid;else if(L.elem[mid]>key)high=mid-1;elselow=mid+1;}return -1;
}//递归写法
int binary_search1(STable L,Elemtype key,int low,int high){if(low>high)return 0;mid=(low+high)/2;if(key>ST.elem[mid])binary_search1(L,key,mid+1,high);else if(key<ST.elem[mid])binary_search1(L,key,low,mid-1);elsereturn mid;
}

顺序检索算法（找到指定结点后与前驱结点交换）

//顺序表存储
int seqsrch(STable L,Elemtype key){int i=0;while(L.elem[i]!=k&&i<n)i++;if(i<n&&i>0){Elemtype t=L.elem[i];L.elem[i]=L.elem[i-1];L.elem[i-1]=t;return --i;}elsereturn -1;
}//链表存储
typedef struct LNode{int data;struct LNode *next;
}LNode,*LinkList;
int seqsrch1(LinkList &L,int key){LNode *p=L;int i=1;if(p->data==key) return i;//第一个结点就是指定结点，无需与前面交换 while(p->next!=NULL){if(p->next->data==key){int t=p->next->data;p->next->data=p->data;p->data=t;return i;}i++;}return -1;
}

二叉排序树

1.查找
BiNode *BST_Search(BiTree T,Elemtype key){while(T!=NULL&&key!=T->data){if(key<T->data) T=T->lchild;else T=T->rchild;}return T;
}2.插入
int BST_Insert(BiTree &T,int k){if(T==NULL){T=(BiTree)malloc(sizeof(BiNode));T->data=k;T->lchild=T->rchild=NULL;return 1;}else if(k==T->data)return 0;else if(k<T->data)return BST_Insert(T->lchild,k);else return BST_Insert(T->rchild,k);
}3.构造
void Creat_BST(BiTree &T,int data[],int n){T=NULL;int i=0;while(i<n){BST_Insert(T,data[i]);i++;}
}4.判断是否是二叉排序树
int pd=-32767;
int JudgeBST(BiTree bt){int b1,b2;if(bt==NULL) return 1;else{b1=JudgeBST(bt->lchild);if(b1==0||pd>=bt->data)return 0;pd=bt->data;b2=JudgeBST(bt->rchild);return b2;}
}5.求指定结点在二叉排序树中的层次
int level(BiTree bt,BiNode *p){int n=0;BiTree t=bt;if(bt!=NULL){n++;while(t->data!=p->data){if(p->data<t->data)t=t->lchild;elset=t->rchild;n++;}}return n;
}6.求最小和最大的关键字（根据二叉排序树性质）
int min_key(BiNode *bt){while(bt->lchild!=NULL)bt=bt->lchild;return bt->data;
}
int max_key(BiNode *bt){while(bt->rchild!=NULL)bt=bt->rchild;return bt->data;
}7.从大到小输出所有value不小于k的关键字
void Out_k(BiNode *bt,int k){if(bt==NULL) return ;if(bt->rchild!=NULL)Out_k(bt->rchild,k);if(bt->data>=k)printf("%d",bt->data);if(bt->lchild!=NULL)Out_k(bt->lchild,k);
}8.查找第k小的元素并返回其指针
typedef struct BiNode{int data;int count;//以该节点为根的子树上的结点个数struct BiNode *lchild,*rchild;
}BiNode,*BiTree;
BiNode *Search_k(BiNode *t,int k){if(k<1||k>t->count) return NULL;if(t->lchild==NULL){if(k==1) return t;else return Search_k(t->rchild,k-1);}else{if(t->lchild->count==k-1) return t;if(t->lchild->count>k-1) return Search_k(t->lchild,k);if(t->lchild->count<k-1)return Search_k(t->rchild,k-(t->lchild->count+1));}
}

判断是否是平衡二叉树

void Judge_AVL(BiTree bt,int &balance,int &h){int bl=0,br=0,hl=0,hr=0;if(bt==NULL){h=0;balance=1;}else if(bt->lchild==NULL&&bt->rchild==NULL){h=1;balance=1;}else{Judge_AVL(bt->lchild,bl,hl);Judge_AVL(bt->rchile,br,hr);h=max(hl,hr)+1;if(abs(hl-hr)<2)balance=bl&&br;else balance=0;}
}

八、排序

插入排序

1.直接插入排序
void InsertSort(ElemType A[],int n){int i,j;for(i=2;i<=n;i++){if(A[i]<A[i-1]){A[0]=A[i];for(int j=i-1;A[0]<A[j];--j)A[j+1]=A[j];A[j+1]=A[0];}}
}2.折半插入排序
void HalfSort(ElemType A[],int n){int i,j,low,high,mid;for(i=2;i<=n;i++){A[0]=A[i];low=1,high=i-1;while(low<=high){mid=(low+high)/2;if(A[mid]>A[0]) high=mid-1;else low=mid+1;}for(j=i-1;j>=high+1;--j)A[j+1]=A[j];A[high+1]=A[0]; }
}3.希尔排序
void ShellSort(ElemType A[],int n){int dk,i,j;for(dk=n/2;dk>=1;dk=dk/2){for(i=dk+1;i<=n;i++){if(A[i]<A[i-dk]){A[0]=A[i];for(j=i-dk;j>0&&A[0]<A[j];j-=dk)A[j+dk]=A[j];A[j+dk]=A[0];}}}
}

交换排序

1.冒泡排序
void BubbleSort(int A[],int n){//数组下标为0 int flag;for(int i=0;i<n-1;i++){flag=0;for(j=n-1;j>i;j--){if(A[j-1]>A[j]){swap(A[j-1],A[j]);flag=1;}if(!flag) return;}}
}2.快速排序
void QuickSort(int A[],int low,int high){if(low<high){int pos=Partition(A,low,high);QuickSort(A,low,pos-1);QuickSort(A,pos+1,high);}
}
int Partition(int A[],int low,int high){int pivot=A[low];while(low<high){while(low<high&&A[high]>=pivot) high--;A[low]=A[high];while(low<high&&A[low]<=pivot) low++;A[high]=A[low];}A[low]=pivot;return low;
}

插入排序衍生题目

1.双向冒泡排序
void DBubbleSort(int A[],int n){//数组下标(0,n-1) int low=0,high=n-1;int flag=1;while(low<high&&flag){flag=0;for(i=low;i<high;i++){if(a[i]>a[i+1]){swap(a[i],a[i+1]);flag=1;}}high--;for(i=high;i>low;i--){if(a[i]<a[i-1]){swap(a[i],a[i+1]);flag=1;}}low++;}
}2.奇数在前偶数在后
void MoveJiOu(int A[],int n){int i=0,j=n-1;while(i<j){while(i<j&&A[j]%2==0){j--;}while(i<j&&A[i]%2==1){i++;}if(i<j){swap(A[i],A[j]);i++,j--;}}
}3.随机枢纽快排
void Partition(int A[],int low,int high){int ran=low+rand()%(high-low+1);swap(A[ran],A[low]);int pivot=A[low];while(low<high){while(low<high&&A[high]>=pivot) high--;A[low]=A[high];while(low<high&&A[low]<=pivot) low++;A[high]=A[low];}A[low]=pivot;return low;
}
void QuickRSort(int A[],int low,int high){if(low<high){int pos=Partition(A,low,high);QuickSort(A,low,pos-1);QuickSort(A,pos+1,high);}
} 4.找第k小元素
int find_mink(int a[],int k,int low,int high){int pivot=a[low];int low_temp=low;int high_temp=high;while(low<high){while(low<high&&a[high]>=pivot){high--;}a[low]=a[high];while(low<high&&a[low]<=pivot){low++;}a[high]=a[low];}a[low]=pivot;if(low==k) return a[low];else if(low>k) find_mink(a,k,low_temp,low-1);elsefind_mink(a,k,low+1,high_temp);
}5.荷兰国旗问题（三色排序）
//red是0，white是1，blue是2
void color_sort(int a[],int n){int cur=0,begin=0,end=n-1;while(cur<=end){if(a[cur]==0){swap(a[begin],a[cur]);cur++,begin++;}else if(a[cur]==2){swap(a[cur],a[end]);end--;}else{cur++;}}
}6.将数组个数均等分成两个数组，两个数组差值最大
int setPartition(int a[],int low,int high){int pivot=a[low];while(low<high){while(low<high&&a[high]>=pivot) high--;a[low]=a[high];while(low<high&&a[low]<=pivot) low++;a[high]=a[low];}a[low]=pivot;return low;
}
void QuickSort(int a[],int low,int high,int mid){if(low<high){int pos=setPartition(a,low,high);if(pos==mid) return;if(pos>mid)QuickSort(a,low,pos-1,mid);if(pos<mid)QuickSort(a,pos+1,high,mid);   }
}
int main()
{int a[]={};//待排序数组 int s1=0,s2=0;QuickSort(a,0,n-1,(n-1)/2);int i,j;for(i=0;i<=(n-1)/2;i++){s1+=a[i];}for(j=i;j<n;j++){s2+=a[j];}cout<<s2-s1;return 0;
}

选择排序

1.简单选择排序
void select_sort(int a[],int n){for(i=0;i<n-1;i++){min=i;for(j=i+1;j<n;j++)if(a[j]<A[min]) min=j;if(min!=i) swap(a[i],a[min]);}
}2.堆排序*（难点）
void BuildMaxHeap(int a[],int len){//建大根堆 for(int i=len/2;i>0;i--){HeadAdjust(A,i,len);}
}
void HeadAdjust(int a[],int k,int len){a[0]=a[k];for(i=2*k;i<=len;i*=2){if(i<len&&a[i]<a[i+1]) i++;if(a[0]>=a[i]) break;else{a[k]=a[i];k=i;}}a[k]=a[0];
}
void HeapSort(int a[],int len){//数组下标(1,n) BuildMaxHeap(a,len);for(int i=len;i>1;i--){swap(a[i],a[1]);HeadAdjust(a,1,i-1);}
}

选择排序拓展题目

1.单链表上进行简单选择排序
void select_sort(LinkList &L){LinkNode *h=L,*p,*q,*r,*s;//p是工作指针，q是p前驱//s是最大值指针，r是s前驱L=NULL;while(h!=NULL){p=s=h;q=r=NULL;while(p!=NULL){if(p->data>s->data){s=p;r=q;}q=p;p=p->next;}if(s==h) h=h->next;//最大值在头结点else r->next=s->next;s->next=L;L=s;}
}2.判断小根堆
bool IsMinHeap(int a[],int len){if(len%2==0){//注意，结点数为偶数二叉树必有一个单分支节点 if(a[len/2]>a[len]) return false;//对其特判 for(int i=len/2-1;i>0;i--){if(a[i]>a[i*2]||a[i]>a[i*2+1])return false;}}else{for(int i=len/2;i>0;i--){if(a[i]>a[i*2]||a[i]>a[i*2+1])return false;}}return true;
}

归并排序

int *b=(int *)malloc((n+1)*sizeof(int));
void Merge(int a[],int low,int mid,int high){for(int k=low;k<=high;k++)b[k]=a[k];for(int i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){if(b[i]<=b[j])a[k]=b[i++];elsea[k]=b[j++];}while(i<=mid) a[k++]=b[i++];while(j<=high) a[k++]=b[j++];
}
void MergeSort(int a[],int low,int high){if(low<high){int mid=(low+high)/2;MergeSort(a,low,mid);MergeSort(a,mid+1,high);Merge(a,low,mid,high);}
}

一些习题
1.计数排序
void CountSort(int a[],int b[],int n){int cnt,i,j;for(i=0;i<n;i++){for(j=0,cnt=0;j<n;j++){if(a[j]<a[i]) cnt++;}b[cnt]=a[i];}
}2.找到无序数组最后一个元素位置（快排思想）
int Partitionk(int a[],int n){int low=0,high=n-1;int pivot=a[n-1];while(low<high){while(low<high&&a[high]>=pivot)high--;a[low]=a[high];while(low<high&&a[low]<=pivot)low++;a[high]=a[low];}a[low]=pivot;return low;
}