版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本代码 来源于同僚吴成伟，仅作参考
顺序线性表功能实现
#include<cstdio>
#include <cctype>
#include<cstdlib>
#include<algorithm>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define CHUSHIHUA 0 //用于初始化线性表数据元素的值，便于移植
typedef int Status;
//整型线性表
typedef int ElemType;
char scan[]="%d"; //用于更换线性表数据元素类型，造成的输入格式的更改，便于移植
char print[]="%d"; //用于更换线性表数据元素类型，造成的输出格式的更改，便于移植
char scan1[]="%d%d"; //用于更换线性表数据元素类型，造成的输入格式的更改，便于移植
/*
//字符型线性表 (每次只能使用一种数据类型的线性表)
typedef char ElemType;
char scan[]="%c";
char print[]="%c";
*/
/*
//浮点型线性表
typedef double ElemType;
char scan[]="%lf";
char print[]="%lf";
*/
int num;
typedef struct {
ElemType *elem;
int length;
int listsize;
}SqList;
/*
int number; //元素的位置
int yuansu;
int qianqu;
int houji;
int flag;
int choose;
int e; //元素e
int cur_e;
int pre_e ; //前驱
int next_e; //后继 */
Status InitList(SqList &L){ //创建空表
if( L.elem )
return ERROR;
L.elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem)
exit(OVERFLOW);
L.length = 0;
L.listsize = LIST_INIT_SIZE;
return OK;
}
Status DestroyList(SqList &L){ //销毁线性表
ElemType *p=&L.elem[L.length-1];
int i=0;
if( !L.elem )
return ERROR;
for(;i<L.length;i++){
free( p );
p--;
}
L.elem=NULL;
return OK;
}
Status ClearList(SqList &L){
if(!L.elem)
return ERROR;
for(int i=0;i<L.length;i++){
L.elem[i] = 0;
}
L.length=0;
return OK;
}
Status ListEmpty(SqList L){
if(L.length==0)
return TRUE;
return FALSE;
}
Status ListLength(SqList L){
if(!L.elem)
return ERROR;
return L.length;
}
Status GetElem(SqList L,int i,ElemType &e){
if(!L.elem || i<0 || i>L.length )
return ERROR;
e = L.elem[i-1];
return OK;
}
Status LocateElem(SqList L,ElemType e){
if( !L.elem )
return ERROR;
int i=0;
for(;i<L.length;i++){
if( e==L.elem[i] ){
num = i+1;
return OK;
}
}
return ERROR;
}
Status PriorElem(SqList L,int cur_e,ElemType &pre_e){
if(!L.elem || L.elem[0]==cur_e )
return ERROR;
int i=1;
for(;i<L.length;i++){
if( L.elem[i]==cur_e ){
pre_e = L.elem[i-1];
return OK;
}
}
return ERROR;
}
Status NextElem(SqList L,int cur_e,ElemType &next_e){
if(!L.elem || L.elem[L.length-1]==cur_e )
return ERROR;
int i=0;
for(;i<L.length;i++){
if( L.elem[i]==cur_e ){
next_e = L.elem[i+1];
return OK;
}
}
return ERROR;
}
Status ListInsert(SqList &L,int i,ElemType e){
if( !L.elem || i<0 || i>L.length+1 ) //空表，或非法数据的判断
return ERROR;
//第i个元素之后的元素开始数据的后移
if(L.length>=L.listsize){
L.elem =(ElemType *)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof(ElemType) );
if(!L.elem)
exit(OVERFLOW);
L.listsize+=LISTINCREMENT;
}
ElemType *end=&L.elem[L.length-1];
ElemType *star=&L.elem[i-1];
for(;end>=star;end--){
*(end+1) = *end;
}
*star = e;
++L.length;
return OK;
}
Status ListDelete(SqList &L,int i,ElemType &e){
if( !L.elem || i<1 || i>L.length+1 )
return ERROR;
ElemType *star = &L.elem[i-1];
ElemType *end = &L.elem[L.length-1];
e = *star;
for(;star<=end;star++){
*star = *(star+1);
}
L.length--;
return OK;
}
void search(SqList L){ //遍历整个线性表
if(!L.elem){
printf("线性表未创建，无法遍历\n");
return ;
}
ElemType *star = L.elem;
int i=1;
ElemType *end = &L.elem[L.length-1];
for(;star<=end;star++,i++){
printf("线性表第 %d ",i);
printf(" 个元素为 ");
printf(print,*star);
printf("\n");
}
}
void WindowsPut(){
system("cls");
printf(" *******************************************************************\n");
printf(" *******************顺序线性表的操作********************************\n");
printf(" *******************************************************************\n");
printf("*** 1 创建空线性表 ***\n");
printf("*** 2 销毁线性表 ***\n");
printf("*** 3 线性表置空 ***\n");
printf("*** 4 线性表判空 ***\n");
printf("*** 5 线性表长度 ***\n");
printf("*** 6 线性表获取元素 ***\n");
printf("*** 7 线性表位置判断 ***\n");
printf("*** 8 线性表前驱元素获取 ***\n");
printf("*** 9 线性表后驱元素获取 ***\n");
printf("*** 10 线性表插入元素 ***\n");
printf("*** 11 线性表删除元素 ***\n");
printf("*** 12 线性表遍历 ***\n");
printf("*** 0 线性表操作结束 ***\n");
printf(" *******************************************************************\n");
if(sizeof(ElemType)==4)
printf(" ************************整型线性表*********************************\n");
else if(sizeof(ElemType)==1)
printf(" ************************字符型线性表*******************************\n");
else
printf(" ************************浮点型线性表*******************************\n");
printf(" *******************************************************************\n");
}
void Choose(int choose){
}
int main(){
SqList L;
L.elem=NULL;
int i; //元素的位置
int choose;
ElemType e;
ElemType qianqu,houji;
printf("代码过程，编译过程有点慢，请稍等......");
while( 1 ){
WindowsPut();
printf("请输入线性表的操作值:");
scanf("%d",&choose);
if(choose==6){
printf("请输入需要获取的元素的位置：");
scanf("%d",&i);
}
else if(choose==8){
printf("请输入需要输出前驱元素的后继： ");
scanf(scan,&qianqu); //scan之前已经定义过了，方便线性表元素数据类型的更改
}
else if(choose==7){
printf("请输入需要判断位置的值");
scanf(scan,&e); //scan之前已经定义过了，方便线性表元素数据类型的更改
}
else if(choose==9){
printf("请输入需要输出后继元素的前驱: ");
scanf(scan,&houji); //scan之前已经定义过了，方便线性表元素数据类型的更改
}
else if(choose==10){
printf("请输入插入元素的位置与元素值: ");
scanf("%d",&i);
getchar();
scanf(scan,&e); //scan之前已经定义过了，方便线性表元素数据类型的更改
}
else if(choose==11){
printf("请输入需要删除元素的位置: ");
scanf("%d",&i);
}
switch(choose){
case 1: InitList(L)==OK? printf("空线性表创建成功") : printf("线性表已创建"); getchar(); break;
case 2: DestroyList(L)==OK? printf("线性表销毁成功") : printf("线性表不存在"); getchar(); break;
case 3: ClearList(L)==OK? printf("线性表置空成功") : printf("线性表不存在"); getchar(); break;
case 4: ListEmpty(L)==TRUE? printf("线性表为空") : printf("线性表不为空"); getchar(); break;
case 5: ListLength(L)==ERROR? printf("线性表不存在") : printf("线性表长为: %d",ListLength(L)); getchar(); break;
case 6: GetElem(L,i,e)==ERROR? printf("线性表不存在或输入数据非法") : printf("元素为: "); printf("%d",e); getchar(); break;
case 7: LocateElem(L,e)==ERROR? printf("线性表不存在或未找到该元素") : printf("该元素所在位置为: "); printf("%d",num); getchar(); break;
case 8: PriorElem(L,qianqu,e)==ERROR? printf("线性表不存在或该元素无前驱") : printf("该元素前驱为： "); printf("%d",e); getchar(); break;
case 9: NextElem(L,houji,e)==ERROR? printf("线性表不存在或该元素无后继") : printf("该元素的后继为: "); printf("%d",e); getchar(); break;
case 10: ListInsert(L,i,e)==ERROR? printf("线性表不存在或输入数据非法") : printf("插入成功"); getchar(); break;
case 11: ListDelete(L,i,e)==ERROR? printf("线性表不存在或输入数据非法") : printf("删除成功"); getchar(); break;
case 12: search(L); getchar(); break;
case 0: printf("操作结束\n"); getchar(); break;
default: printf("输入操作数据值非法"); getchar(); break;
}
if(choose==0)
break;
getchar();
}
return 0;
}
链式线性表功能实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
char print[]="%d";
char scan[]="%d";
typedef int Status;
typedef int ElemType;
typedef struct node{
int data;
struct node *next;
}Node,*pNode;
Status CreatList(pNode &L){
printf("\nCreatList");
L = (pNode)malloc(sizeof(Node));
if(!L)
exit(OVERFLOW);
L->next = NULL;
return OK;
}
Status ListEmpty(pNode L){
printf("\nListEmpty");
if(L->next==NULL)
return OK;
else
return ERROR;
}
Status ListLength(pNode L){
printf("\nListLength");
int i=0;
pNode p = L->next;
while(p){
p=p->next;
i++;
}
return i;
}
Status getElem(pNode L,int i,ElemType &e){
printf("\ngetElem");
pNode p = L->next;
int j = 1;
while(p&&i<i){ //讲指针调到 i 元素的前面
p = p->next;
j++;
}
if(!p||j>i)
return ERROR;
e = p->data;
return OK;
}
Status ListInsert(pNode &L,int i,ElemType e){
printf("\nListINset");
pNode p = L; //为了不破坏线性表的结构，而临时创建的指针
int j = 1;
while(L&&j<i){
p = p->next;
j++;
}
if(!p||j>i)
return ERROR;
pNode now = (pNode)malloc(sizeof(Node));
now->data = e;
now->next = p->next;
p->next = now;
return OK;
}
Status ListDelete(pNode &L,int i,ElemType &e){
printf("\nListDelete");
pNode p = L;
int j = 0;
while(p->next && j<i-1){
p = p->next;
j++;
}
if(!(p->next) || j>i-1 )
return ERROR;
pNode q = p->next;
p->next = q->next;
e = q->data;
free(q);
return OK;
}
Status ListLocateElem(pNode L,int &i,ElemType e){
printf("\nListLocateElem");
if(L->next==NULL)
return ERROR;
pNode q = L->next;
int j = 0;
while(q){
if( q->data==e ){
return OK;
}
q = q->next;
j++;
}
return ERROR;
}
Status ListTraverse(pNode L){
if(L->next==NULL){
printf("线性表为空");
return ERROR;
}
int i = 1;
pNode p = L->next;
while(p){
ElemType e=p->data;
printf("第%d个元素为:",i);
printf(print,e);
printf("\n");
i++;
p=p->next;
}
return OK;
}
void WindowsPut(){
system("cls");
printf(" *******************************************************************\n");
printf(" *******************链式线性表的操作********************************\n");
printf(" *******************************************************************\n");
printf("*** 1 创建空线性表 ***\n");
printf("*** 2 销毁线性表 ***\n");
printf("*** 3 线性表判空 ***\n");
printf("*** 4 线性表长度 ***\n");
printf("*** 5 线性表获取元素 ***\n");
printf("*** 6 线性表位置判断 ***\n");
printf("*** 7 线性表插入元素 ***\n");
printf("*** 8 线性表删除元素 ***\n");
printf("*** 9 线性表遍历 ***\n");
printf("*** 0 线性表操作结束 ***\n");
printf(" *******************************************************************\n");
if(sizeof(ElemType)==4)
printf(" ************************整型线性表*********************************\n");
else if(sizeof(ElemType)==1)
printf(" ************************字符型线性表*******************************\n");
else
printf(" ************************浮点型线性表*******************************\n");
printf(" *******************************************************************\n");
}
int main(){
pNode L;
L=NULL;
ElemType e;
int i,choose;
/* printf("main");
CreatList(L);
getElem(L,1,e);
ListEmpty(L);
ListInsert(L,1,e);
ListLength(L);
ListDelete(L,1,e);
ListLocateElem(L,1,e);
printf("\n");*/
while(1){
WindowsPut();
printf("请输入线性表的操作值:");
scanf("%d",&choose);
if(choose==5){
printf("请输入需要获取的元素的位置");
}
if(choose==6){
printf("请输入需要判断位置的元素的值: ");
scanf(scan,&e);
}
if(choose==7){
printf("请输入需要插入的元素的位置与元素的值");
scanf("%d",&i);
scanf(scan,&e);
}
if(choose==8){
printf("请输入需要删除的元素的位置");
scanf("%d",&i);
}
switch(choose){
case 1: CreatList(L)==OK? printf("链式线性表创建成功") : printf("链式线性表已被创建"); getchar(); break;
case 2: break;
case 3: ListEmpty(L)==OK? printf("链式线性表为空") :printf("链式线性表不为空"); getchar(); break;
case 4: printf("%d ",ListLength(L)); getchar(); break;
case 5: getElem(L,i,e)==OK? printf(print,e):printf("元素的位置非法"); getchar(); break;
case 6: ListLocateElem(L,i,e)==OK? printf("该元素的为第 %d 个",i):printf("该元素不存在"); getchar(); break;
case 7: ListInsert(L,i,e)==OK? printf("插入成功") : printf("元素的位置非法"); getchar(); break;
case 8: ListDelete(L,i,e)==OK? printf("删除成功") : printf("元素的位置非法"); getchar(); break;
case 9: ListTraverse(L); getchar(); break;
case 0: printf("链式线性表操作结束"); break;
default: printf("输入操作数据值非法"); getchar(); break;
}
if(choose==0)
break;
getchar();
}
return 0;
}
链式栈的实现方法
//栈的顺序存储实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
typedef int SElemType;
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef struct{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;
Status InitStack(SqStack &S){
if(S.base!=NULL){
printf("栈已被构造");
return ERROR;
}
S.base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base)
exit(OVERFLOW);
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
printf("栈构造成功");
return OK;
}
Status DestroyStack(SqStack &S){
return OK;
}
Status ClearStack(SqStack &S){
if(S.base==NULL){
printf("栈没有构造，无法置空");
return ERROR;
}
S.top = S.base;
printf("栈置空成功");
return OK;
}
Status StackEmpty(SqStack S){
if(S.base==NULL){
printf("栈没有被构造");
return INFEASIBLE;
}
if(S.base==S.top){
printf("栈为空");
return TRUE;
}
else{
printf("栈不为空");
return ERROR;
}
}
int StackLength(SqStack S){
if(S.base==NULL)
return INFEASIBLE;
if(S.top==S.base)
return 0;
int i = 0;
SElemType *p=S.top;
while(p!=S.base){
SElemType e = *p;
p--;
i++;
}
return i;
}
Status GetTop(SqStack S,SElemType &e){
if(S.top==S.base)
return ERROR;
e = *--S.top;
return OK;
}
Status Push(SqStack &S,SElemType &e){
if(S.top-S.base>=S.stacksize){
S.base = (SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!S.base)
exit(OVERFLOW);
S.top = S.base + S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}
Status Pop(SqStack &S,SElemType &e){
if(S.top==S.base)
return ERROR;
e = *--S.top;
return OK;
}
Status StackTreaverse(SqStack S){
if(S.base==NULL)
return INFEASIBLE;
if(S.base==S.top){
printf("栈空，无元素");
return OK;
}
SElemType *p = S.top;
int i=1;
SElemType e;
while(p!=S.base){
if(i!=1)
printf("\n");
e = *--p;
printf("距栈顶元素长为%-3d的元素为: %d",i++,e);
}
return OK;
}
void WindowsPut(){
system("cls");
printf(" *******************************************************************\n");
printf(" ********************链式栈的操作***********************************\n");
printf(" *******************************************************************\n");
printf("*** 1 创建空栈 ***\n");
printf("*** 2 销毁栈 ***\n");
printf("*** 3 栈置空 ***\n");
printf("*** 4 栈判空 ***\n");
printf("*** 5 栈长 ***\n");
printf("*** 6 栈顶元素获取 ***\n");
printf("*** 7 入栈 ***\n");
printf("*** 8 出栈 ***\n");
printf("*** 9 栈遍历 ***\n");
printf("*** 0 线性表操作结束 ***\n");
printf(" *******************************************************************\n");
if(sizeof(SElemType)==4) //用来判断存放线性中的数据类型
printf(" ************************整型栈*************************************\n");
else if(sizeof(SElemType)==1)
printf(" ************************字符型栈***********************************\n");
else
printf(" ************************浮点型栈***********************************\n");
printf(" *******************************************************************\n");
}
int main(){
SqStack S;
S.base=NULL;
SElemType e;
int choose;
while( 1 ){
WindowsPut();
printf("\t请输入栈的操作数: ");
scanf("%d",&choose);
if(choose==7){
printf("请输入入栈的元素的值：");
scanf("%d",&e);
}
switch(choose){
case 1: InitStack(S); getchar(); break;
case 2: DestroyStack(S); getchar(); break;
case 3: ClearStack(S); getchar(); break;
case 4: StackEmpty(S); getchar(); break;
case 5: StackLength(S)==INFEASIBLE? printf("栈空，无元素") : printf("%d",StackLength(S)); getchar(); break;
case 6: GetTop(S,e)==ERROR? printf("栈空，无栈顶元素") : printf("栈顶元素为:%d",e); getchar(); break;
case 7: Push(S,e); printf("插入成功"); getchar(); break;
case 8: Pop(S,e)==ERROR? printf("栈空，无栈顶元素可以出栈"): printf("栈顶元素，出栈成功"); getchar(); break;
case 9: StackTreaverse(S); getchar(); break;
case 0: printf("栈的操作结束");getchar(); break;
default: printf("输入操作数据值非法,请重新输入"); getchar(); break;
}
if(choose==0)
break;
getchar();
}
return 0;
}
链式队列的实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
//1.数据类型为 int时
typedef int QElemType;
char scan[]="%d";
char print[]="%d";
/*
//2.数据类型为double时
typedef double QElemType;
char scan[]="%lf";
char print[]="%.3lf";
*/
typedef struct QNode{
QElemType data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
QueuePtr front;
QueuePtr rear;
}LinkQueue;
Status InitQueue(LinkQueue &Q){
Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
if(!Q.front)
exit(OVERFLOW);
Q.front->next = NULL;
return OK;
}
Status DestroyQueue(LinkQueue &Q){
while(Q.front){
Q.rear = Q.front->next;
free(Q.front);
Q.front = Q.rear;
}
return OK;
}
Status ClearQueue(LinkQueue &Q){ //没有
return OK;
}
Status QueueEmpty(LinkQueue Q){
if(Q.front==Q.rear)
return OK;
else
return ERROR;
}
Status QueueLength(LinkQueue Q){
if(Q.front==Q.rear)
return INFEASIBLE;
QueuePtr p = Q.front->next;
int i=0;
while(p){
i++;
p=p->next;
}
return i;
}
Status GetHead(LinkQueue Q,QElemType &e){
if(Q.front->next==NULL)
return ERROR;
else
e = Q.front->next->data;
printf("队列的队头元素为: ");
return OK;
}
Status EnQueue(LinkQueue &Q,QElemType &e){ //插入元素
QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
if(!p)
exit(OVERFLOW);
p->data = e;
p->next = NULL;
Q.rear->next = p;
Q.rear = p;
return OK;
}
Status DeQueue(LinkQueue &Q,QElemType &e){
if(Q.front==Q.rear)
return ERROR;
QueuePtr p = Q.front->next;
e = p->data;
Q.front->next = p->next;
//也可以写成
//Q.front->next = Q.front->next->next;
if(Q.rear==p)
Q.rear = Q.front;
free(p);
return OK;
}
Status QueueTraverse(LinkQueue Q){
if(Q.front==Q.rear){
printf("队列为空,无法遍历元素");
return ERROR;
}
QueuePtr p = Q.front->next;
int i = 1;
while(p){
if(i!=1)
printf("\n"); //为了排版的好看,第一个元素不换行
QElemType e = p->data;
printf("第%d个元素为: ",i++);
printf(print,e);
//如果QElemType的数据类型为int,也可以写成printf("%d\n",e);
p=p->next;
}
return OK;
}
void WindowsPut(){
system("cls");
printf(" *******************************************************************\n");
printf(" *********************链式队列的实现********************************\n");
printf(" *******************************************************************\n");
printf("*** 1 创建空队列 ***\n");
printf("*** 2 销毁队列 ***\n");
printf("*** 3 队列判空 ***\n");
printf("*** 4 队列求长度 ***\n");
printf("*** 5 获取队列头元素 ***\n");
printf("*** 6 队列插入元素 ***\n");
printf("*** 7 队列头出队列 ***\n");
printf("*** 8 队列元素遍历 ***\n");
printf("*** 0 队列操作结束 ***\n");
printf(" *******************************************************************\n");
if(sizeof(QElemType)==4)
printf(" *************************整型队列**********************************\n");
else if(sizeof(QElemType)==1)
printf(" ************************字符型队列*********************************\n");
else
printf(" ************************浮点型队列*********************************\n");
printf(" *******************************************************************\n");
}
int main(){
QElemType e;
int choose;
LinkQueue Q;
while(1){
WindowsPut();
printf("请输入队列的操作数: ");
scanf("%d",&choose);
if(choose==6){
printf("请输入需要插入队头的元素:");
scanf(scan,&e);
}
switch(choose){
case 1: InitQueue(Q); printf("空队列创建成功"); getchar(); break;
case 2: DestroyQueue(Q); printf("队列销毁成功"); getchar(); break;
case 3: QueueEmpty(Q)==OK? printf("队列为空") : printf("队列不为空"); getchar(); break;
case 4: QueueLength(Q)==INFEASIBLE? printf("队列为空,无长度") : printf("队列长为: %d ",QueueLength(Q)); getchar(); break;
case 5: GetHead(Q,e)==ERROR? printf("队列为空,无队头元素"):printf("%d ",e); getchar(); break;
case 6: EnQueue(Q,e); printf("插入成功"); getchar(); break;
case 7: DeQueue(Q,e)==ERROR? printf("队列为空,无法删除队头元素"):printf("删除成功"); getchar(); break;
case 8: QueueTraverse(Q); getchar(); break;
case 0: printf("队列操作结束"); getchar(); break;
default: printf("输入操作数据值非法,请重新输入操作数"); getchar(); break;
}
if(choose==0)
break;
getchar();
}
return 0;
}
循环队列的实现
#include<stdio.h>
#include<stdlib.h>
#define MAXQSIZE 100 //循环队列的初始化长度（定长）
#define OVERFLOW -2
#define OK 1
#define ERROR 0
typedef int QElemType;
typedef int Status;
typedef struct{
QElemType *base;
int front;
int rear;
}SqQueue;
Status InitQueue(SqQueue &Q){
Q.base = (QElemType *)malloc(MAXQSIZE * sizeof(QElemType)); //初始化的动态分配储存空间
if(!Q.base) //如果分配失败，结束程序
exit(OVERFLOW);
Q.front=Q.rear=0;
return OK;
}
Status DestroyQueue(SqQueue &Q){
int i=0;
for(i=0;i<MAXQSIZE;i++)
free(Q.base+i);
return OK;
}
Status ClearQueue(SqQueue &Q){
Q.front=Q.rear=0;
return OK;
}
Status QueueEmpty(SqQueue &Q){
if(Q.front==Q.rear)
return OK;
else
return ERROR;
}
Status QueueLength(SqQueue &Q){
return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
return OK;
}
Status GetHead(SqQueue &Q,QElemType &e){
if(Q.rear==Q.front)
return ERROR;
e=Q.base[Q.front];
return OK;
}
Status EnQueue(SqQueue &Q,QElemType &e){
if( (Q.rear+1)%MAXQSIZE==Q.front )
return ERROR;
Q.base[Q.rear] = e;
Q.rear=(Q.rear+1)%MAXQSIZE;
return OK;
}
Status DeQueue(SqQueue &Q,QElemType &e){
if(Q.front==Q.rear)
return ERROR;
e=Q.base[Q.front];
Q.front = (Q.front+1)%MAXQSIZE;
return OK;
}
Status QueueTraverse(SqQueue &Q){
if(Q.front==Q.rear){
printf("队列为空");
return ERROR;
}
int star=Q.front;
int end=Q.rear;
QElemType e;
int i=1;
while(star!=end){
if(i!=1)
printf("\n");
e=Q.base[star];
printf("第%d个元素为:\t%d",i++,e);
star = (star+1)%MAXQSIZE;
}
return OK;
}
void WindowsPut(){
system("cls");
printf(" *******************************************************************\n");
printf(" *******************循环链式队列的实现******************************\n");
printf(" *******************************************************************\n");
printf("*** 1 创建空队列 ***\n");
printf("*** 2 销毁队列 ***\n");
printf("*** 3 队列置空 ***\n");
printf("*** 4 队列判空 ***\n");
printf("*** 5 队列求长度 ***\n");
printf("*** 6 获取队列头元素 ***\n");
printf("*** 7 队列插入元素 ***\n");
printf("*** 8 队列头出队列 ***\n");
printf("*** 9 队列元素遍历 ***\n");
printf("*** 0 队列操作结束 ***\n");
printf(" *******************************************************************\n");
if(sizeof(QElemType)==4)
printf(" *************************整型队列**********************************\n");
else if(sizeof(QElemType)==1)
printf(" ************************字符型队列*********************************\n");
else
printf(" ************************浮点型队列*********************************\n");
printf(" *******************************************************************\n");
}
int main(){
SqQueue Q;
QElemType e;
int choose;
while(1){
WindowsPut();
printf("\t请输入循环队列的操作数: ");
scanf("%d",&choose);
if(choose==7){
printf("请输入需要入队列的元素: ");
scanf("%d",&e);
}
switch(choose){
case 1: InitQueue(Q); printf("循环队列创建成功"); getchar(); break;
case 2: DestroyQueue(Q); printf("循环队列销毁成功"); getchar(); break;
case 3: ClearQueue(Q); printf("循环队列置空成功"); getchar(); break;
case 4: QueueEmpty(Q)==OK? printf("循环队列为空"):printf("循环队列不为空"); getchar(); break;
case 5: printf("循环队列的长度为:%d",QueueLength(Q)); getchar(); break;
case 6: GetHead(Q,e)==ERROR? printf("循环队列无元素"):printf("队列头元素为:%d",e); getchar();break;
case 7: EnQueue(Q,e)==ERROR? printf("循环队列已满，无法入队列"):printf("入队列成功"); getchar(); break;
case 8: DeQueue(Q,e)==ERROR? printf("队列无元素，无法出队列"):printf("出队列成功"); getchar(); break;
case 9: QueueTraverse(Q); getchar(); break;
case 0: printf("循环队列操作结束"); getchar(); break;
default: printf("输入操作数据值非法,请重新输入操作数"); getchar(); break;
}
if(choose==0)
break;
getchar();
}
return 0;
}