1)线性表
//顺序存储下线性表的操作实现 #include <stdio.h> #include <stdlib.h> typedef int ElemType; /*线性表的顺序存储(静态) struct List { ElemType list[MaxSize]; int size; }; */ //线性表的顺序存储(动态分配) struct List { ElemType *list; /*存线性表元素的动态存储空间的指针*/ int size; /*存线性表长度*/ int MaxSize; /*存list数组长度，亦即所能存储线性表的最大长度*/ }; void againMalloc(struct List *L) { ElemType *p=realloc(L->list, 2*L->MaxSize*sizeof(ElemType)); //空间扩展为原来的2倍，并由p指针所指向，原内容被 //自动拷贝到p所指向的存储空间中 if(!p) { //分配失败退出运行 printf("存储空间用完! "); exit(1); } L->list=p; //使list指向新线性表空间 L->MaxSize=2*L->MaxSize; //把线性表空间大小修改为新的长度 } /********************************************************************************** 1. 初始化线性表L，即进行动态存储空间分配并置L为一个空表 **********************************************************************************/ void InitList(struct List *L,int ms) { /*检查ms是否有效，若无效则退出运行*/ if(ms<=0) {printf("ms值非法! "); exit(1);} /*置线性表空间大小为ms*/ L->MaxSize=ms; /*动态存储空间分配，若分配失败则退出运行*/ L->list=malloc(ms*sizeof(ElemType)); if(!L->list) { printf("动态存储分配失败! "); exit(1); /*执行此函数则中止程序运行，此函数在stdlib.h中有定义*/ } /*初始置线性表为空*/ L->size=0; } /********************************************************************************** 2. 清除线性表L中的所有元素，释放动态存储空间，使之成为一个空表 **********************************************************************************/ void ClearList(struct List *L) { if(L->list!=NULL) { free(L->list); /*释放存储空间*/ L->list=0; L->size=L->MaxSize=0; } } /********************************************************************************** 3. 返回线性表L的长度，若L为空则返回0 **********************************************************************************/ int SizeList(struct List *L) { return L->size; } /********************************************************************************** 4. 判断线性表L是否为空，若为空则返回1，否则返回0 **********************************************************************************/ int EmptyList(struct List *L) { if(L->size==0) return 1; else return 0; } /********************************************************************************** 5. 返回线性表L中第pos个元素的值，若pos超出范围，则停止程序运行 **********************************************************************************/ ElemType GetElem(struct List *L,int pos) { if(pos<1||pos>L->size) { /*若pos越界则退出运行*/ printf("元素序号越界! "); exit(1); } return L->list[pos-1]; /*返回线性表中序号为pos值的元素值*/ } /********************************************************************************** 6. 顺序扫描（即遍历）输出线性表L中的每个元素 **********************************************************************************/ void TraverseList(struct List *L) { int i; for(i=0;i<L->size;i++) printf("%d",L->list[i]); printf(" "); } /********************************************************************************** 7. 从线性表L中查找其值与x相等的元素，若查找成功则返回其位置，否则返回-1 **********************************************************************************/ int FindList(struct List *L,ElemType x) { int i; for(i=0;i<L->size;i++) if(L->list[i]==x) return i; return -1; } //当ElemType为字符串类型时，if条件表达式应该为(strcmp(L->list[i],x)==0) /********************************************************************************** 8. 把线性表L中第pos个元素的值修改为x的值，若修改成功返回1，否则返回0 **********************************************************************************/ int UpdatePosList(struct List *L,int pos, ElemType x) { if(pos<1 || pos>L->size+1) /*若pos越界则修改失败*/ return 0; L->list[pos-1]=x; return 1; } /********************************************************************************** 9. 向线性表L的表头插入元素x **********************************************************************************/ void InsertFirstList(struct List *L, ElemType x) { int i; if(L->size==L->MaxSize) againMalloc(L); /*调用此函数重新分配更大的存储空间*/ for(i=L->size-1; i>=0; i--) L->list[i+1]=L->list[i]; L->list[0]=x; L->size++; } /* 下面给出againMalloc的函数定义： void againMalloc(struct List *L) { ElemType *p=realloc(L->list, 2*L->MaxSize*sizeof(ElemType)); //空间扩展为原来的2倍，并由p指针所指向，原内容被 //自动拷贝到p所指向的存储空间中 if(!p) { //分配失败退出运行 printf("存储空间用完! "); exit(1); } L->list=p; //使list指向新线性表空间 L->MaxSize=2*L->MaxSize; //把线性表空间大小修改为新的长度 } //向顺序存储的线性表的表头插入一个元素时，需要移动线性表中的所有元素，所有算法的时间复杂度为O(n)，n表示线性表长度。 */ /********************************************************************************** 10. 向线性表L的表尾插入元素x **********************************************************************************/ void InsertLastList(struct List *L, ElemType x) { if(L->size==L->MaxSize) againMalloc(L); /*调用此函数重新分配更大的存储空间*/ L->list[L->size]=x; L->size++; } /********************************************************************************** 11. 向线性表L中第pos个元素位置插入元素x，若插入成功返回1，否则返回0 **********************************************************************************/ int InsertPosList(struct List *L, int pos, ElemType x) { int i; if(pos<1 || pos>L->size+1) /*若pos越界则插入失败*/ return 0; if(L->size==L->MaxSize) /*重新分配更大的存储空间*/ againMalloc(L); for(i=L->size-1; i>=pos-1; i--) L->list[i+1]=L->list[i]; L->list[pos-1]=x; L->size++; return 1; } /********************************************************************************** 12. 向有序线性表L中插入元素x，使得插入后仍然有序 **********************************************************************************/ void InsertOrderList(struct List *L, ElemType x) { int i,j; /*若数组空间用完则重新分配更大的存储空间*/ if(L->size==L->MaxSize) againMalloc(L); /*顺序查找出x的插入位置*/ for(i=0; i<L->size; i++) if(x<L->list[i]) break; /*从表尾到下标i元素依次后移一个位置，把i位置空出*/ for(j=L->size-1; j>=i; j--) L->list[j+1]=L->list[j]; /*把x值赋给下标为i的元素*/ L->list[i]=x; /*线性表长度增1*/ L->size++; } /********************************************************************************** 13. 从线性表L中删除表头元素并返回它，若删除失败则停止程序运行 **********************************************************************************/ ElemType DeleteFirstList(struct List *L) { ElemType temp; int i; if(L->size==0) { printf("线性表为空，不能删除! "); exit(1); } temp=L->list[0]; for(i=0; i<L->size; i++) L->list[i-1]=L->list[i]; L->size--; return temp; } /********************************************************************************** 14. 从线性表L中删除表尾元素并返回它，若删除失败则停止程序运行 **********************************************************************************/ ElemType DeleteLastList(struct List *L) { if(L->size==0) { printf("线性表为空，不能删除! "); exit(1); } L->size--; return L->list[L->size]; } /********************************************************************************** 15. 从线性表L中删除第pos个元素并返回它，若删除失败则停止程序运行 **********************************************************************************/ ElemType DeletePosList(struct List *L, int pos) { ElemType temp; int i; if(pos<1 || pos>L->size) { /*pos越界则删除失败*/ printf("pos值越界，不能删除! "); exit(1); } temp=L->list[pos-1]; for(i=pos; i<L->size; i++) L->list[i-1]=L->list[i]; L->size--; return temp; } //在这个算法中，运行时间主要花费在第(3)步前移n-pos个元素的操作上。若删除任一位置上元素的概率都相同，即均为1/n，则每次删除一个元素的平均移动元素次数为，所以该算法的时间复杂度为O(n)。 /********************************************************************************** 16. 从线性表L中删除值为x的第一个元素，若删除成功返回1否则返回0 **********************************************************************************/ int DeleteValueList(struct List *L, ElemType x) { int i,j; /*从线性表中顺序查找出值为x的第一个元素*/ for(i=0; i<L->size; i++) if(L->list[i]==x) break; /*若查找失败,表明不存在值为x的元素,应返回0*/ if(i==L->size) return 0; /*删除值为x的元素L->list[i]*/ for(j=i+1; j<L->size; j++) L->list[j-1]=L->list[j]; /*线性表长度减1*/ L->size--; /*删除成功返回1*/ return 1; } void main() { int a[10]={2,4,6,8,10,12,14,16,18,20}; int i; struct List L; InitList(&L,5); for(i=0;i<10;i++) InsertLastList(&L, a[i]); InsertPosList(&L,11,48); InsertPosList(&L,1,64); printf("%d ",GetElem(&L,4)); TraverseList(&L); printf("%d ",FindList(&L,10)); UpdatePosList(&L,3,20); DeleteFirstList(&L); DeleteFirstList(&L); DeleteLastList(&L); DeleteLastList(&L); DeletePosList(&L, 5); DeletePosList(&L, 7); printf("%d ",SizeList(&L)); printf("%d ",EmptyList(&L)); TraverseList(&L); /* ClearList(&L); */ }
2) 单链表
//单链表的C语言描述 #include <stdio.h> #include <stdlib.h> #define NN 12 #define MM 20 //链表结构体定义 typedef int ElemType; struct sNode { ElemType data; /*值域*/ struct sNode* next; /*链接指针域*/ }; //1、初始化线性表，即置单链表表头指针为空 void InitList(struct sNode** HL) { *HL=NULL; } //2、清除线性表中所有元素，即释放单链表中所有结点，使之成为一个空表 void ClearList(struct sNode** HL) { /*用cp和np分别作为指向两个相邻结点的指针*/ struct sNode *cp, *np; /*单链表的表头指针赋给*cp*/ cp=*HL; /*遍历单链表，依次释放每个结点*/ while(cp!=NULL) { np=cp->next; free(cp); cp=np; } /*置单链表的表头指针为空*/ *HL=NULL; } //3、返回线性表L的长度，即单链表的长度 int SizeList(struct sNode* HL) { int i; /*用来统计结点个数*/ while(HL!=NULL) { i++; HL=HL->next; } return i; } //4、检查单链表是否为空 int EmptyList(struct sNode* HL) { if(HL==NULL) return 1;else return 0; } //5. 返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行 ElemType GetElem(struct sNode* HL, int pos) { int i=0; /*统计已遍历的结点数*/ if(pos<1) { printf("pos值非法，退出运行! "); exit(1); } while(HL!=NULL) { i++; if(i==pos) break; HL=HL->next; } if(HL!=NULL) return HL->data; else { printf("pos值非法，退出运行! "); exit(1); } } //6、遍历一个单链表 void TraverseList(struct sNode* HL) { while(HL!=NULL) { printf("%5d",HL->data); HL=HL->next; } printf(" "); } //11. 向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回1，否则返回 int InsertPosList(struct sNode** HL, int pos, ElemType x) { int i=0; struct sNode *newp; struct sNode* cp=*HL, *ap=NULL; /*对pos值小于等于0的情况进行处理*/ if(pos<=0) { printf("pos值不正确,返回0表示插入失败! "); return 0; } /*查找第pos个结点*/ while(cp!=NULL) { i++; if(pos==i) break; else {ap=cp; cp=cp->next;} } /*产生新结点，若分配失败，则停止插入*/ newp=malloc(sizeof(struct sNode)); if(newp==NULL) { printf("内存动态空间用完，无法插入! "); return 0; } /*把x的值赋给新结点的data域*/ newp->data=x; /*把新结点插入到表头*/ if(ap==NULL) { newp->next=cp; /*或改为newp->next=*HL*/ *HL=newp; } /*把新结点插入到ap和cp之间*/ else { newp->next=cp; ap->next=newp; } /*插入成功返回1*/ return 1; } //12. 向有序单链表中插入元素x结点，使得插入后仍然有序 void InsertOrderList(struct sNode** HL, ElemType x) { /*把单链表的表头指针赋给cp，把空赋给ap*/ struct sNode* cp=*HL, *ap=NULL; /*建立新结点*/ struct sNode *newp; newp=malloc(sizeof(struct sNode)); if(newp==NULL) { printf("内存动态空间用完，退出运行! "); exit(1); } newp->data=x; /*把x的值赋给新结点的data域*/ /*把新结点插入到表头*/ if(cp==NULL || x<cp->data) { newp->next=cp; *HL=newp; return; } /*顺序查找出x结点的插入位置*/ while(cp!=NULL) { if(x<cp->data) break; else {ap=cp; cp=cp->next;} } /*把x结点插入到ap和cp之间*/ newp->next=cp; ap->next=newp; } //16. 从单链表中删除值为x的第一个结点，若删除成功则返回1否则返回0 int DeleteValueList(struct sNode** HL, ElemType x) { /*初始化cp和ap指针，使cp指向表头结点，使ap为空*/ struct sNode* cp=*HL; struct sNode* ap=NULL; /*从单链表中查找值为x的结点，找到后由cp指向该结点，由 ap指向其前驱结点*/ while(cp!=NULL) { if(cp->data==x) break; ap=cp; cp=cp->next; } /*若查找失败，即单链表中不存在值为x的结点,则返回0*/ if(cp==NULL) return 0; /*对删除的是表头或非表头分别进行处理*/ if(ap==NULL) *HL=(*HL)->next; /*或改为*HL=cp->next*/ else ap->next=cp->next; /*回收被删除的结点*/ free(cp); /*返回1表示删除成功*/ return 1; } void main() { int a[NN]; int i; struct sNode *p;//*h,*s, InitList(&p); for(i=0;i<NN;i++) a[i]=rand()%MM; printf("随机数序列:"); for(i=0;i<NN;i++) printf("%5d",a[i]); printf(" "); printf("向链表中插入结点 "); InsertPosList(&p, 1, 1); InsertPosList(&p, 1, 2); InsertPosList(&p, 1, 3); TraverseList(p); printf("单链表长度：%5d ",SizeList(p)); ClearList(&p); }
3)双向链表
#include<string.h> #include<ctype.h> #include<malloc.h> #include<limits.h> #include<stdio.h> #include<stdint.h> #include<stdlib.h> #include<stdbool.h> #include<math.h> typedef struct DuLNode { int data; struct DuLNode *prev,*next; }DuLNode,*DuLinkList; bool InitList(DuLinkList *L) { *L=(DuLinkList)malloc(sizeof(DuLNode)); if(*L) { (*L)->next=(*L)->prev=*L; return true; } else return false; } bool DestroyList(DuLinkList *L) { DuLinkList q,p=(*L)->next; while(p!=*L) { q=p->next; free(p); p=q; } free(*L); *L=NULL; return true; } bool ClearList(DuLinkList L) { DuLinkList q,p=L->next; while(p!=L) { q=p->next; free(p); p=q; } L->next=L->prev=L; return true; } bool ListEmpty(DuLinkList L) { if(L->next==L&&L->prev==L) return true; else return false; } int ListLength(DuLinkList L) { int i=0; DuLinkList p=L->next; while(p!=L) { i++; p=p->next; } return i; } bool GetElem(DuLinkList L,int i,int *e) { int j=1; DuLinkList p=L->next; while(p!=L&&j<i) { p=p->next; j++; } if(p==L||j>i) return false; *e=p->data; return true; } int LocateElem(DuLinkList L,int e) { int i=0; DuLinkList p=L->next; while(p!=L) { i++; if(p->data==e) return i; p=p->next; } return 0; } bool PriorElem(DuLinkList L,int cur_e,int *pre_e) { DuLinkList p=L->next->next; while(p!=L) { if(p->data==cur_e) { *pre_e=p->prev->data; return true; } p=p->next; } return false; } bool NextElem(DuLinkList L,int cur_e,int *next_e) { DuLinkList p=L->next->next; while(p!=L) { if(p->prev->data==cur_e) { *next_e=p->data; return true; } p=p->next; } return false; } DuLinkList GetElemP(DuLinkList L,int i) { int j; DuLinkList p=L; for(j=1;j<=i;j++) p=p->next; return p; } bool ListInsert(DuLinkList L,int i,int e) { DuLinkList p,s; if(i<1||i>ListLength(L)+1) return false; p=GetElemP(L,i-1); if(!p) return false; s=(DuLinkList)malloc(sizeof(DuLNode)); if(!s) return false; s->data=e; s->prev=p; s->next=p->next; p->next->prev=s; p->next=s; return true; } bool ListDelete(DuLinkList L,int i,int *e) { DuLinkList p; if(i<1||i>ListLength(L)) return false; p=GetElemP(L,i); if(!p) return false; *e=p->data; p->prev->next=p->next; p->next->prev=p->prev; free(p); return true; } void ListTraverse(DuLinkList L) { DuLinkList p=L->next; while(p!=L) { printf("%d ",(p->data)); p=p->next; } printf(" "); } void ListTraverseBack(DuLinkList L) { DuLinkList p=L->prev; while(p!=L) { printf("%d ",(p->data)); p=p->prev; } printf(" "); } int main(void) { DuLinkList L; int i,n; bool j; int e; InitList(&L); for(i=1;i<=5;i++) ListInsert(L,i,i); printf("正序输出链表："); ListTraverse(L); printf("逆序输出链表："); ListTraverseBack(L); n=2; ListDelete(L,n,&e); printf("删除第%d个结点，值为%d，其余结点为：",n,e); ListTraverse(L); printf("链表的元素个数为%d ",ListLength(L)); printf("链表是否空：%d(1:是 0:否) ",ListEmpty(L)); ClearList(L); printf("清空后，链表是否空：%d(1:是 0:否) ",ListEmpty(L)); for(i=1;i<=5;i++) ListInsert(L,i,i); ListTraverse(L); n=3; j=GetElem(L,n,&e); if(j) printf("链表的第%d个元素值为%d ",n,e); else printf("不存在第%d个元素 ",n); n=4; i=LocateElem(L,n); if(i) printf("等于%d的元素是第%d个 ",n,i); else printf("没有等于%d的元素 ",n); j=PriorElem(L,n,&e); if(j) printf("%d的前驱是%d ",n,e); else printf("不存在%d的前驱 ",n); j=NextElem(L,n,&e); if(j) printf("%d的后继是%d ",n,e); else printf("不存在%d的后继 ",n); DestroyList(&L); return 0; }
4) 队列
//队列的C语言描述 #include <stdio.h> #include <stdlib.h> typedef int ElemType; //队列的顺序存储结构同样可以被定义在一个记录类型中，假定该记录类型用QueueSq表示，则定义为： /* struct QueueSq { ElemType queue[MaxSize]; int front, rear, len; }; */ //若要对存储队列的数组空间采用动态分配，则QueueSq结构类型可定义为： struct QueueSq { ElemType *queue; /*指向存储队列的数组空间*/ int front, rear, len; /*队首指针、队尾指针、队列长度变量*/ int MaxSize; /*queue数组长度*/ }; void againMalloc(struct QueueSq* Q) { /*空间扩展为原来的2倍，并由p所指向，原内容被自动 拷贝到p所指向的存储空间中*/ ElemType *p; p=realloc(Q->queue, 2*Q->MaxSize*sizeof(ElemType)); if(!p) { /*分配失败退出运行*/ printf("存储空间用完! "); exit(1); } /*使queue指向新的队列空间*/ Q->queue=p; /*把原队列的尾部内容向后移动MaxSize个位置*/ if(Q->rear!=Q->MaxSize-1) { int i; for(i=0; i<=Q->rear; i++) Q->queue[i+Q->MaxSize]=Q->queue[i]; Q->rear+=Q->MaxSize; /*队尾指针后移MaxSize个位置*/ } /*把队列空间大小修改为新的长度*/ Q->MaxSize=2*Q->MaxSize; } //1. 初始化队列 //第一种情况是隐含分配用于存储队列的固定大小的动态存储空间，假定动态存储空间的大小为10。 /* void InitQueue(struct QueueSq* Q) { //置队列空间初始最大长度为10 Q->MaxSize=10; //动态存储空间分配 Q->queue=malloc(10*sizeof(ElemType)); //置队列为空 Q->front=Q->rear=0; } */ //第二种情况是分配由参数指定大小的动态存储空间。实用中使用任一种初始化算法均可。 void InitQueue(struct QueueSq* Q, int ms) { /*检查ms是否有效，若无效则退出运行*/ if(ms<=0) {printf("ms值非法! "); exit(1);} /*置队列空间大小为ms*/ Q->MaxSize=ms; /*动态存储空间分配，若分配失败则退出运行*/ Q->queue=malloc(ms*sizeof(ElemType)); if(!Q->queue) { printf("内存空间用完! "); exit(1); } /*初始置队列为空*/ Q->front=Q->rear=0; } //2. 向队列插入元素 void EnQueue(struct QueueSq* Q, ElemType x) { /*当队列满时进行动态重分配*/ if((Q->rear+1)%Q->MaxSize==Q->front) againMalloc(Q); /*求出队尾的下一个位置*/ Q->rear=(Q->rear+1)%Q->MaxSize; /*把item的值赋给新的队尾位置*/ Q->queue[Q->rear]=x; }//againMalloc()算法的具体定义如上： //3. 从队列中删除元素并返回 ElemType OutQueue(struct QueueSq* Q) { /*若队列为空则终止运行*/ if(Q->front==Q->rear) { printf("队列已空，无法删除! "); exit(1); } /*使队首指针指向下一个位置*/ Q->front=(Q->front+1)%Q->MaxSize; /*返回队首元素*/ return Q->queue[Q->front]; } //4.读取队列首元素，不改变队列状态 ElemType PeekQueue(struct QueueSq* Q) { /*若队列为空则退出运行*/ /*若队列为空则终止运行*/ if(Q->front==Q->rear) { printf("队列已空，无法读取! "); exit(1); } /*对首元素是队列指针的下一个位置中的元素*/ return Q->queue[(Q->front+1)%Q->MaxSize]; } //5.检查一个队列是否为空，若是则返回1，否则返回0 int EmptyQueue(struct QueueSq* Q) { if(Q->front==Q->rear) return 1; else return 0; } //6.清空一个队列，并释放动态存储空间 void ClearQueue(struct QueueSq* Q) { if(Q->queue!=NULL){ free(Q->queue); Q->queue=0; Q->front=0; Q->MaxSize=0; } } void main() { struct QueueSq q; int a[8]={3,8,5,17,9,30,15,22}; int i; InitQueue(&q, 5); for(i=0;i<8;i++) EnQueue(&q, a[i]); printf("%d",OutQueue(&q));printf("%d ",OutQueue(&q)); while(!EmptyQueue(&q)) printf("%d",OutQueue(&q)); printf(" "); ClearQueue(&q); }
5）队列的链接存储
//链队的C语言描述 #include <stdio.h> #include <stdlib.h> typedef int ElemType; //链表结构体定义 struct sNode { ElemType data; /*值域*/ struct sNode* next; /*链接指针域*/ }; //链接队列结构体定义 struct QueueLk { struct sNode* front; /*队首指针*/ struct sNode* rear; /*队尾指针*/ }; //1. 初始化链队 void InitQueue(struct QueueLk* HQ) { HQ->front=HQ->rear=NULL; /*把队首和队尾指针置为空*/ } //2. 向链队中插入一个元素 void EnQueue(struct QueueLk* HQ, ElemType x) { /*得到一个由newp指针所指向的新结点*/ struct sNode* newp; newp=malloc(sizeof(struct sNode)); if(newp==NULL) { printf("内存动态空间用完，退出运行! "); exit(1); } /*把x的值赋给新结点的值域，把新结点的指针域置空*/ newp->data=x; newp->next=NULL; /*若链队为空，则新结点既是队首结点又是队尾结点*/ if(HQ->rear==NULL) HQ->front=HQ->rear=newp; /*若链队非空，则依次修改队尾结点的指针域和队尾指针， 使之指向新的队尾结点*/ else HQ->rear=HQ->rear->next=newp; } //3. 从队列中删除一个元素 ElemType OutQueue(struct QueueLk* HQ) { struct sNode* p; ElemType temp; /*若链队为空则中止运行*/ if(HQ->front==NULL) { printf("队列为空无法删除! "); exit(1); } /*暂存队首元素以便返回*/ temp=HQ->front->data; /*暂存队首指针以便回收队首结点*/ p=HQ->front; /*使队首指针指向下一个结点*/ HQ->front=p->next; /*若删除后链队变为空，则需同时使队尾指针变为空*/ if(HQ->front==NULL) HQ->rear=NULL; /*回收原队首结点，返回被删除的队首元素*/ free(p); return temp; } //4.读取队列首元素 ElemType PeekQueue(struct QueueLk* HQ) { /*若链队为空则中止运行*/ if(HQ->front==NULL) { printf("队列为空无法读取! "); exit(1); } return HQ->front->data; } //5.检查队列是否为空 int EmptyQueue(struct QueueLk* HQ) { /*判断对首或对尾任一个指针为空即可*/ if(HQ->front==NULL) return 1; else return 0; } //6.清空一个队列，并释放动态存储空间 void ClearQueue(struct QueueLk* HQ) { /*对首指针赋给p*/ struct sNode* p=HQ->front; while(p!=NULL){ HQ->front=HQ->front->next; free(p); p=HQ->front; }/*循环结束后对首指针已经变为空*/ /*置对尾指针为空*/ HQ->rear=NULL; } void main() { struct QueueLk HQ; int a[8]={3,8,5,17,9,30,15,22}; int i,temp; InitQueue(&HQ); for(i=0;i<8;i++) EnQueue(&HQ, a[i]); printf("%d",OutQueue(&HQ)); printf("%d ",OutQueue(&HQ)); temp=PeekQueue(&HQ); printf("%d ",temp); while(!EmptyQueue(&HQ)) printf("%d",OutQueue(&HQ)); printf(" "); ClearQueue(&HQ); }
6) 顺序栈
/********************************************************** 以下是顺序栈的C语言实现 **********************************************************/ #include <stdlib.h> //初始长度为100 #define StackSize 100 typedef char DataType; typedef struct stack{ DataType data[StackSize]; int top; }SqStack; //初始化栈 void InitStack(SqStack *S) { S->top = -1; } //判断是否为空 int StackEmpty(SqStack *S) { return S->top == -1; } //判断是否满栈 int StackFull(SqStack *S) { return S->top == StackSize-1; } //入栈 void push(SqStack *S,DataType d) { if (StackFull(S)) { printf("Stack is full!"); exit(-1); } S->data[++S->top] = d; } //出栈 DataType pop(SqStack *S) { if (StackEmpty(S)) { printf("Stack is empty! "); exit(-1); } return(S->data[S->top--]); } //显示 void disp(SqStack *S) { if (StackEmpty(S)) { printf("Stack is empty! "); exit(-1); } int count = S->top; printf("The elements of stack are: "); while(S->top != -1) { printf("%c ",S->data[S->top--]); } S->top = count; } int main() { SqStack *S; S = (SqStack *)malloc(sizeof(SqStack)); printf("Initialize the stack. "); InitStack(S); push(S,'a'); push(S,'b'); push(S,'c'); push(S,'d'); disp(S); printf("pop a element "); DataType aa = pop(S); disp(S); DataType bb = pop(S); disp(S); DataType cc = pop(S); disp(S); DataType dd = pop(S); disp(S); DataType ee = pop(S); disp(S); return 1; }
…