數據結構代碼

• 順序表
• • 靜態存儲SqList
  • 動態存儲SqList
• 單鏈表LinkList
• 雙鏈表DLinkList
• 循環單鏈表LinkList
• 循環雙鏈表DLinkList
• 順序棧SqStack
• 鏈棧LiStack（這里王道用了不帶頭節點的單鏈表，確實好）
• 順序隊列SqQueue
• 鏈式隊列LinkQueue
• 應用
• • （1）括號匹配
  • （2）中綴表達式
  • （3）遞歸
• 串
• • 順序存儲
  • 鏈式存儲
  • 模式匹配
  • • 樸素模式匹配
    • KMP算法
• 樹
• • 順序存儲
  • 鏈式存儲
  • 線索二叉樹
• 樹
• • 雙親存儲法
  • 孩子表示法（順序+鏈式存儲）
  • 孩子兄弟表示法（鏈式存儲）
  • 二叉查找樹BST（二叉排序樹）
  • 平衡二叉樹（AVL樹）
• 圖
• • 鄰接矩陣
  • 鄰接表
• 查找
• • 順序查找
  • 折半查找
• 排序
• • 堆排序

順序表

靜態存儲SqList

#include<stdio.h> #include<stdlib.h>#define InitSize 5 #define MaxSize 10typedef struct{int data[MaxSize];int length; }SqList;void InitList(SqList &L){L.length=0; }bool Insert(SqList &L,int i,int e){//the range of iif(i<1||i>L.length+1)return false;//beyond the max,cause wasteif(L.length>MaxSize){return false;}//back movefor(int j=L.length;j>=i;j--){L.data[j]=L.data[j-1];}L.data[i-1]=e;L.length++;return true; }bool Delete(SqList &L,int i,int &e){//the range of iif(i<1||i>L.length){return false;}//give e the valuee=L.data[i-1];//cover the datafor(int j=i;j<L.length;j++){L.data[j-1]=L.data[j];}return true;}int GetElemByA(SqList L,int i){if(i<1||i>L.length) return 0;return L.data[i-1]; }int GetElemByD(SqList L,int e){for(int i=0;i<L.length;i++){if(L.data[i]==e) return i+1;}return 0; }int main(){SqList L;InitList(L);int e;Insert(L,3,3);Delete(L,3,e);return 0; }

動態存儲SqList

#include<stdio.h> #include<stdlib.h>#define InitSize 5 #define MaxSize 10typedef struct{int *data;int length;int maxsize; }SqList;void InitList(SqList &L){L.data=(int *)malloc(InitSize*sizeof(int));L.length=0;L.maxsize=InitSize; }void IncreaseSize(SqList &L,int len){int *p=L.data;L.data=(int *)malloc(len*sizeof(int));for(int i=0;i<L.length;i++){L.data[i]=p[i]; }L.maxsize+=len; }int main(){SqList L;InitList(L);IncreaseSize(L,5);return 0; }

單鏈表LinkList

#include<stdio.h> #include<stdlib.h>typedef struct LNode{int data;//int *next; zhelidezhizheng shijiegoutizhizhengstruct LNode* next; }LNode,*LinkList;//No head node bool InitList(LinkList &L){L=NULL;return true; }//Has a head node (In practice, I usually write this bool InitListHead(LinkList &L){L=(LNode *)malloc(sizeof(LNode));if(L==NULL) return false;L->next=NULL;return true; }bool ListInsert(LinkList &L,int i,int e){if(i<1) return false;LNode *p=L;int j=0;for(;p!=NULL&&j<i-1;j++){p=p->next;} if(p==NULL) return true;//dang i beyond lengthLNode *s=(LNode *)malloc(sizeof(LNode));s.data=e;s.next=p->next;p->next=s;return true; }int main(){LinkList L;InitListHead(L);return 0; }

雙鏈表DLinkList

#include<stdio.h> #include<stdlib.h>typedef struct DNode{int data;DNode *prior,*next; }DNode, *DLinkList;//初始化雙鏈表 bool InitDLinkList(DLinkList &L){L=(DNode *)malloc(sizeof(DNode));if(L==NULL) return false;L->prior=NULL;L->next=NULL;return true; } //判斷為空bool Empty(DLinkList &L){if(L->next==NULL) return true;else return false;} //雙鏈表的插入 ,在p節點后插入s節點 bool InsertNextDNode(DNode *p,DNode *s){if(s==NULL||p==NULL){return false;}s->next=p->next;/********************這一步很關鍵*/ if(p->next!=NULL){p->next->prior=s;}/************************* */p->next=s;s->prior=p;return true; }//雙鏈表的刪除，刪除p節點的后繼節點 bool DeleteNextDNode(DNode *p){if(p==NULL) return false;DNode *q=p->next;if(q==NULL) return false;p->next=q->next;if(q->next!=NULL){q->next->prior=p ;}free(q);return true; } //雙鏈表的刪除 void Destory(DLinkList &L){while(L->next!=NULL){DeleteNextDNode(L->next);}free(L);L=NULL; } int main(){DLinkList L;InitDLinkList(L);return 0; }

循環單鏈表LinkList

#include<stdio.h> #include<stdlib.h>typedef struct LNode{int data;LNode *next; }LNode,*LinkList;//初始化循環單鏈表 bool InitLinkList(LinkList &L){L=(LNode*)malloc(sizeof(LNode));if(L==NULL) return false;L->next=L;return true; } //空表是指頭節點后面沒有其他節點的線性表 bool Empty(LinkList L){if(L->next==NULL) return true;else return false; }int main(){DLinkList L;InitDLinkList(L);return 0; }

循環雙鏈表DLinkList

#include<stdio.h> #include<stdlib.h>typedef struct DNode{int data;DNode *prior,*next; }DNode,*DLinkList;//初始化循環單鏈表 bool InitDLinkList(DLinkList &L){L=(DNode*)malloc(sizeof(DNode));if(L==NULL) return false;L->next=L;L->prior=L;return true; } //判斷雙鏈表是否為空 bool Empty(DLinkList L){if(L->next==NULL) return true;else return false; } //判斷p是否為循環雙鏈表的表尾節點 bool IsTail(DLinkList L,DNode *p){if(p->next==L) return true;else false; } //雙鏈表的插入。在p節點后插入s節點 bool InsertNextDNode(DNode *p,DNode *s){s->next=p->next;p->next->prior=s;p->next=s;s->prior=p; } //雙鏈表的刪除(刪除p節點的后繼節點 bool DeleteDNode(DNode *p){if(p==NULL) return false;DNode *q=p->next;p->next=q->next;q->next->prior=p; free(q); } int main(){DLinkList L;InitDLinkList(L);return 0; }

順序棧SqStack

#include<stdio.h> #include<stdlib.h>#define MaxSize 10 #define ElemType int typedef struct{ElemType data[MaxSize];int top; }SqStack;void InitStack(SqStack &S){S.top=-1; }//top 指針永遠指向當前數據的位置 bool Push(SqStack &S,ElemType x){//判斷棧滿 if(S.top==MaxSize-1){return false;}S.top=S.top+1;S.data[S.top]=x;//S.data[++S.top]=x; return true; }bool Pop(SqStack &S,ElemType &x){if(S.top==-1){return false;}x=S.data[S.top--];return true; }top指針指向下一個可以插入的位置 //bool Push1(SqStack &S,ElemType x){ // //判斷棧滿 // if(S.top==MaxSize)return false; // S.data[S.top++]=x; // return true; //} //bool Pop1(SqStack &S,ElemType &x){ // if(S.top==0)return false; // x=S.data[--S.top]; //}int main(){SqStack S;}

鏈棧LiStack（這里王道用了不帶頭節點的單鏈表，確實好）

#include<stdio.h> #include<stdlib.h>#define ElemType int typedef struct LinkNode{ElemType data;struct LinkNode *next; } *LiStack;//不帶頭節點 bool InitLiStack(LiStack &S){S=NULL;return true; } bool Push(LiStack &S,ElemType x){LinkNode *p;p=(LinkNode *)malloc(sizeof(LinkNode));if(p==NULL) return false;p->data=x;p->next=S->next;S->next=p;return true; } bool Pop(LiStack &S,ElemType x){if(S==NULL){return false;}LinkNode *q=S;S=q->next;free(q);return true; }bool GetTop(LiStack S,ElemType &x){if(S==NULL) return false;x=S->data;return true; } int main(){return 0; }

順序隊列SqQueue

#include<stdio.h> #include<stdlib.h>#define MaxSize 10 #define ElemType int typedef struct {ElemType data[MaxSize];int front,rear;//rear 指向下一個可以存放數據的單元 }SqQueue;void InitQueue(SqQueue &Q){Q.front=Q.rear=0; }bool QueueEmpty(SqQueue &Q){if(Q.rear==Q.front) return true;else return false; }//入隊操作 bool EnQueue(SqQueue &Q,ElemType x){//判斷隊滿 if((Q.rear+1)%MaxSize==Q.front) return false; //入隊操作犧牲了一個存儲單元，換取隊滿的判斷條件，否則會與隊空條件重復 /*解決一個浪費的方法有1、隊列里再加一個size變量 ，記錄當前隊列長度 2、隊列里再加一個tag變量記錄上一步刪除（0）/插入（1） */Q.data[Q.rear]=x;Q.rear=(Q.rear+1)%MaxSize;//如果只是Q.rear++ ,那么這個隊列無法實現循環使用 return true; } //出隊操作 bool DeQueue(SqQueue &Q,ElemType &x){if(QueueEmpty(Q)) return false;x=Q.data[Q.front];Q.rear=(Q.rear-1)%MaxSize;return true; } //查 bool GetHead(SqQueue Q,ElemType &x){if(Q.front==Q.rear) return false;x=Q.data[Q.front];return true; } int main(){SqQueue Q;InitQueue(Q);return 0; }

鏈式隊列LinkQueue

#include<stdio.h> #include<stdlib.h>#define ElemType int /* 隊頭刪除元素，隊尾添加元素 入隊注意第一個，出隊注意最后一個 數據結構是一種工具 */ //當結構體內部引用了本身時，必須要給結構體起名字 typedef struct LinkNode{ElemType data;struct LinkNode *next; }LinkNode;typedef struct{LinkNode *front;LinkNode *rear; }LinkQueue;//初始化帶頭節點（推薦） bool InitQueue(LinkQueue &Q){Q.front=(LinkNode*)malloc(sizeof(LinkNode));Q.rear=Q.front;Q.front->next=NULL;return true; }//初始化不帶頭結點 bool InitQueue1(LinkQueue &Q){Q.front=Q.rear=NULL;return true; } bool QueueEmpty(LinkQueue Q){if(Q.front==Q.rear) return true;else return false; }//新元素入隊，帶頭節點 bool EnQueue(LinkQueue &Q,ElemType x){LinkNode *s=(LinkNode* )malloc(sizeof(LinkNode));s->data=x;s->next=NULL;Q.rear->next=s;Q.rear=s;return true; } //新元素入隊，不帶頭節點 bool EnQueue1(LinkQueue &Q,ElemType x){LinkNode *s=(LinkNode*)malloc(sizeof(LinkNode));s->data=x;s->next=NULL;if(Q.front==Q.rear){Q.front=Q.rear=s;}else{Q.rear->next=s;Q.rear=s;} } //新元素出隊(帶頭節點） bool DeQueue(LinkQueue &Q,ElemType &x){if(Q.front==Q.rear) return false;else{LinkNode *q=Q.front->next;x=q->data;Q.front->next=q->next;//如果是最后一個元素出隊，需要修改尾指針 if(Q.rear==q){Q.rear=Q.front}free(q);return true;} } //新元素出隊（不帶頭節點） bool DeQueue1(LinkQueue &Q,ElemType &x){if(Q.front==NULL) return false;else{LinkNode *q=Q.front;x=q.data;Q.front=q->next;if(Q.rear==q){ //這個判斷條件很重要，q就是隊尾 Q.front=NULL;Q.rear=NULL;}free(q);return true;} } int main(){return 0; }

應用

（1）括號匹配

/* 括號匹配 這里棧的操作都采用了簡寫 */ #include<stdio.h> #include<stdlib.h>#define MaxSize 10 #define ElemType char typedef struct{ElemType data[MaxSize];int top; }SqStack; void InitStack(SqStack &S){S.top=0; }void Push(SqStack &S,ElemType x){S.data[S.top++]=x; }void Pop(SqStack &S,ElemType &x){x=S.data[--S.top]; }bool StackEmpty(SqStack S){if(S.top==0) return true;else return false; }bool testBracketCheck(){SqStack S;InitStack(S);char a[50];gets(a);int i=0;while(a[i]!='\0'){ElemType topdata;if(a[i]=='{'||a[i]=='['||a[i]=='(') Push(S,a[i]);else{if(a[i]=='}') {Pop(S,topdata);if(topdata!='{') return false;}else if(a[i]==']') {Pop(S,topdata);if(topdata!='[') return false;}else if(a[i]==')') {Pop(S,topdata);if(topdata!='(') return false;}}i++;}return StackEmpty(S); }int main(){if(testBracketCheck()) printf("Success!\n");else printf("Error!\n");return 0; }

（2）中綴表達式

（3）遞歸

/* Recursive factorial Fibonacci sequence */ #include<stdio.h>int Factorial(int n){if(n==0||n==1) return 1;else return n*Factorial(n-1); }int Fib(int n){if(n==0) return 0;else if(n==1) return 1;else return Fib(n-1)+Fib(n-2); }int main(){printf("Factorial ->%d\n",Factorial(5));printf("Fib ->%d\n",Fib(5));return 0; }

串

順序存儲

#include<stdio.h> #include<stdlib.h> #define MaxSize 10//靜態數組實現 typedef struct{char ch[MaxSize];int length; }SString; //動態數組實現 typedef struct{char* ch;int length; }HString;//求子串(返回從pos開始的len個元素的子串 bool SubString(SString &Sub,SString S,int pos,int len){if(pos+len-1>S.length)return false;for(int i=pos;i<pos+len;i++){Sub.ch[i-pos+1]=S.ch[i];}Sub.length=len;return true; }//比較兩個字串 int StrCompare(SString S,SString T){for(int i=1;i<S.length&&i<T.length;i++){if(S.ch[i]!=T.ch[i])return S.ch[i]-T.ch[i];}return S.length-T.length; } //定位操作,主串是S int Index(SString S,SString T){int i=1,m=S.length,n=T.length;SString sub;while(i<=m-n+1){SubString(sub,S,i,n);if(StrCompare(sub,T)!=0) ++i;else return i;}return 0;} void testSString(){HString S;S.ch=(char *)malloc(sizeof(char)*MaxSize);S.length=0; }int main(){testSString();return 0; }

鏈式存儲

#include<stdio.h> #include<stdlib.h>typedef struct StringNode{char ch[4];struct StringNode* next; }StringNode,*String;

模式匹配

樸素模式匹配

//樸素模式匹配 int IndexPlus(SString S,SString T){int i=1,j=1;while(i<=S.length&&j<=T.length){if(S.ch[i]==T.ch[i]){++i;++j;}else {i=i-j+2;j=1;}}if(j>T.length) return i-T.length;else return 0; }

KMP算法

//KMP算法 int Index_KMP(SString S,SString T,int next[]) {int i=1,j=1;while(i<=S.length&&j<=T.length){//匹配字串 if(S.ch[i]==T.ch[j]||j==0){//匹配成功，繼續比較后繼字符 ++i;++j;}//模式串向右移動 else j=next[j];//匹配失敗，主串指針不回溯 }if(j>T.length) return i-T.length;else return 0; }

樹

順序存儲

#include<stdio.h> #include<stdlib.h> #define MaxSize 10struct TreeNode{ElemType value;//節點中的數據元素bool IsEmpty;//節點是否為空 };int main(){TreeNode t[MaxSize];for(int i=0;i<MaxSize;i++){t[i].IsEmpty=true;}return 0; }

鏈式存儲

#include<stdio.h> #include<stdlib.h> #define MaxSize 10 #define ElemType BiTNode//二叉樹結點 struct ElemType{int value; }; typedef struct BiTNode{ElemType data;struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;//鏈式隊列結點 typedef struct LinkNode{BiTNode *data;struct LinkNode *next; }LinkNode;typedef struct {LinkNode *front,*rear; }LinkQueue; //訪問節點 void visit(BiTree T){printf("%d\n",T->data.value); } //前序遍歷 void PreOrder(BiTree T){if(T!=NULL){visit(T);PreOrder(T->lchild);PreOrder(T->rchild);} }//不帶頭節點 bool InitQueue(LinkQueue &Q){Q.front=Q.rear=NULL;return true; } bool QueueEmpty(LinkQueue Q){if(Q.front==Q.rear) return true;else return false; } //新元素入隊，不帶頭節點 bool EnQueue(LinkQueue &Q,ElemType x){LinkNode *s=(LinkNode*)malloc(sizeof(LinkNode));s->data=x;s->next=NULL;if(Q.front==Q.rear){Q.front=Q.rear=s;}else{Q.rear->next=s;Q.rear=s;} } //新元素出隊（不帶頭節點） bool DeQueue(LinkQueue &Q,ElemType &x){if(Q.front==NULL) return false;else{LinkNode *q=Q.front;x=q.data;Q.front=q->next;if(Q.rear==q){ //這個判斷條件很重要，q就是隊尾 Q.front=NULL;Q.rear=NULL;}free(q);return true;} } //層序遍歷 void LevelOrder(BiTree T){LinkQueue Q;InitQueue(Q);//設置一個中間結點指針備用BiTree p;//根結點入隊 EnQueue(Q,T);while(!QueueEmpty(Q)){DeQueue(Q,p);//訪問出隊結點 visit(p);if(p->lchild!=NULL)EnQueue(Q,p->lchild);if(p->rchild!=NULL)EnQueue(Q,p->rchild);} } //求樹的深度 int treeDepth(BiTree T){if(T==NULL) return 0;else{int l=treeDepth(T->lchild);int r=treeDepth(T->rchild);return l>r?l+1:r+1;} } int main(){//定義一個空樹 BiTree root=NULL;//插入根節點root=(BiTree)malloc(sizeof(BiTNode));root->data={1};root->lchild=NULL;root->rchild=NULL;//插入左孩子BiTNode *p=(BiTNode *)malloc(sizeof(BiTNode));p->data={2};p->lchild=NULL;p->rchild=NULL;root->lchild=p;return 0; }

線索二叉樹

#include<stdio.h> #include<stdlib.h> #define MaxSize 10//線索二叉樹的結點 struct ElemType{int value; }; typedef struct ThreadNode{ElemType data;struct ThreadNode *lchild,*rchild;int ltag,rtag; }ThreadNode,*ThreadTree; //指向當前訪問結點的前驅 ThreadNode *pre=NULL; //訪問結點，同時修改tag值 void visit(ThreadNode *q){if(q->lchild==NULL){ //左子樹為空，建立前驅線索q->lchild=pre; q->ltag=1;}if(pre->rchild==NULL&&pre!=NULL){pre->rchild=q; //建立后繼線索 pre->rtag=1;}pre=q;//修改pre指針到q，訪問操作完成 } //先序線索化 void PreThread(ThreadTree T){if(T!=NULL){visit(T); //先處理根節點if(T->ltag==0){PreThread(T->lchild);} PreThread(T->rchild); } } //中序遍歷二叉樹，一邊遍歷一遍線索化 void InThread(ThreadTree T){if(T!=NULL){InThread(T->lchild);visit(T);InThread(T->rchild);} } //中序線索化二叉樹T void CreateInThread(ThreadTree T){pre=NULL; //pre指針初始化為空if(T!=NULL){InThread(T);if(pre->rchild==NULL){pre->rtag=1;}} } int main(){return 0; }

中序線索二叉樹實現中序遍歷

#include<stdio.h> #include<stdlib.h>struct ElemType{int value; }; typedef struct ThreadNode{ElemType data;struct ThreadNode *lchild,*rchild;int ltag,rtag;//0為子樹，1為前驅后繼(線索化） }ThreadNode,*ThreadTree;//找到中序第一個結點 ThreadNode *FristNode(ThreadNode *p){while(p!=NULL) p=p->lchild;return p; }ThreadNode *NextNode(ThreadNode *p){if(p->rtag==0) return FristNode(p->rchild);else return p->rchild; } ///中序線索二叉樹實現中序遍歷 void InOrder(ThreadTree T){for(ThreadNode *p=FristNode(T);p!=NULL;p=NextNode(T))visit(T); }int main(){return 0; }

樹

雙親存儲法

#include<stdio.h> #include<stdlib.h>#define MaxSize 100 #define ElemType int//順序存儲 typedef struct{ //樹的結點定義 ElemType data;int parent; //雙親的位置域，不存在雙親置為-1 }PTNode;typedef struct{ //樹的類型定義 PTNode nodes[MaxSize];int n; }PTree;int main(){return 0; }

孩子表示法（順序+鏈式存儲）

#include<stdio.h> #include<stdlib.h>#define MaxSize 100 #define ElemType int//孩子表示法，在順序存儲的基礎上，用鏈表的方式存儲它的孩子節點的位置 struct CTNode{ //定義鏈表結點 int child;struct CTNode*next; }; struct CTBox{int data;CTNode *firstNode;//一個記錄該結點所有孩子的鏈表； }; struct CTree{ //順序存儲所有結點 CTBox nodes[MaxSize];int n; };int main(){return 0; }

孩子兄弟表示法（鏈式存儲）

#include<stdio.h>typedef struct CSNode{ElemType data;struct CSNode *firstchild,*nextsibling;//第一個孩子和右兄弟指針 }CSNode,*CSTree;

二叉查找樹BST（二叉排序樹）

#include<stdio.h> #include<stdlib.h> typedef struct BSTNode{int key;struct BSTNode *lchild,*rchild; }BSTNode,*BSTree;//在二叉查找樹中找到值為key的結點(非遞歸，迭代實現） BSTNode *BST_Search(BSTree T,int key){while(T!=NULL&&T->key!=key){if(T->key<key) T=T->lchild;else return T=T->rchild;}return T; } //在二叉查找樹中找到值為key的結點(遞歸實現） BSTNode *BST_Search1(BSTree T,int key){if(T==NULL) return NULL;if(key==T->key) return T;else if(key<T->key) return BST_Search(T->lchild,key);else return BST_Search(T->rchild,key); }//在二叉排序樹中插入值為k的結點(遞歸實現） int BST_Insert(BSTree &T,int k){//子樹為空，新插入結點if(T==NULL){T=(BSTNode *)malloc(sizeof(BSTNode));T->key=k;T->lchild=T->rchild=NULL;return 1;}//樹中存在相同關鍵字的結點，插入失敗else if(T->key==k) return 0;//插入到左子樹else if(k<T->key) return BST_Insert(T->lchild,k);//插入到右子樹 else return BST_Insert(T->lchild,k); } //按照str[]關鍵字序列建立二叉排序樹 void Create_BST(BSTree &T,int str[],int n){//建立根結點T=NULL;int i=0; //依次插入每個結點 while(i<n){BST_Insert(T,str[i]);i++;} }

平衡二叉樹（AVL樹）

#include<stdio.h> #include<stdlib.h>//平衡二叉樹的結點 typedef struct AVLNode{int key;int balance;struct AVLNode *lchild,*rchild; }AVLNode,*AVLNode;

圖

鄰接矩陣

#define MaxVertexNum 100 #define INFINITY 2147483647//最大的int值 typedef char VertexType; typedef int EdgeType;typedef struct{VertexType Vex[MaxVertexNum]; //頂點表 EdgeType Edge[MaxVertexNum][MaxVertexNum]; //邊表 int vexnum,arcnum; //圖的頂點數和弧數 }MGraph;

鄰接表

#include<stdio.h> #include<stdlib.h>#define MaxVertexNum 100 typedef struct ArcNode{ //邊表結點 int adjvex;struct ArcNode *next; }ArcNode;typedef struct VNode{ //頂點表結點 VertexType data;ArcNode *first; }VNode,AdjList[MaxVertexNum];typedef struct{ //鄰接表 AdjList vertices;int vexnum,arcnum; }ALGraph;

查找

順序查找

#include<stdio.h> #include<stdlib.h>#define MaxVertexNum 100 typedef struct{ElemType *elem;//0號單元留空int TableLen;//表的長度 }SSTable;int Search_Seq(SSTable ST,ElemType key){ST.elem[0]=key; //哨兵 for(i=ST.TableLen;ST.elem[i]!=key;--i);return i; }

折半查找

#include<stdio.h> #include<stdlib.h>#define MaxVertexNum 100 typedef struct{ElemType *elem;//0號單元留空int TableLen;//表的長度 }SeqList;int Binary_Search(SeqList L,ElemType key){int low=0,high=L.TableLen,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; }

排序

堆排序

#include <stdio.h> #include <stdlib.h>void swap(int* a, int* b) {int temp = *b;*b = *a;*a = temp; }void max_heapify(int arr[], int start, int end) {//建立父節點指標和子節點指標int dad = start;int son = dad * 2 + 1;while (son <= end) //若子節點指標在范圍內才做比較{if (son + 1 <= end && arr[son] < arr[son + 1]) //先比較兩個子節點大小，選擇最大的son++;if (arr[dad] > arr[son]) //如果父節點大於子節點代表調整完畢，直接跳出函數return;else //否則交換父子內容再繼續子節點和孫節點比較{swap(&arr[dad], &arr[son]);dad = son;son = dad * 2 + 1;}} }void heap_sort(int arr[], int len) {int i;//初始化，i從最後一個父節點開始調整for (i = len / 2 - 1; i >= 0; i--)max_heapify(arr, i, len - 1);//先將第一個元素和已排好元素前一位做交換，再重新調整，直到排序完畢for (i = len - 1; i > 0; i--) {swap(&arr[0], &arr[i]);max_heapify(arr, 0, i - 1);} }int main() {int arr[] = { 3, 5, 3, 0 };int len = (int) sizeof(arr) / sizeof(*arr);heap_sort(arr, len);int i;for (i = 0; i < len; i++)printf("%d ", arr[i]);printf("\n");return 0; }

總結

以上是生活随笔為你收集整理的数据结构代码的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。