顺序队列与链式队列--C语言实现

关于队列，因为我自己在平时使用不多，所以在这里直接将队列的两种存储方式放在一起，作为一篇随笔，这两份代码均可直接运行，亲测。注释写的应该也算比较详细了，就不过多的解释了

顺序队列

 #include<stdio.h>
 #define MAXSIZE 100                            //队列最大空间
 typedef int QElemType;                        //队列中元素类型
 typedef int Status;                            //返回值类型
 #define OK 1                                //操作成功
 #define ERROR 0                                //操作失败

 typedef struct                                //队列结点结构
 {
     QElemType date[MAXSIZE];                //结点元素
     int front;                                //队头
     int rear;                                //队尾
 }SqQueue;

 /*队列的初始化*/
 Status InitQue(SqQueue *Q)
 {                                            //因为这是一个int型队列，，所以
     Q->front = ;                            //队头指向0
     Q->rear = ;                            //队尾指向0
     return OK;
 }

 /*队列的入队操作*/
 Status EnQueue(SqQueue *Q, QElemType e)
 {
     if((Q->rear + ) % MAXSIZE == Q->front)                //判断队列是否已满
         return ERROR;
     Q->date[Q->rear] = e;                                //队尾赋值为e
     Q->rear = (Q->rear + ) % MAXSIZE;                    //队尾后移
     return OK;
 }

 /*队列的出队操作*/
 Status DeQueue(SqQueue *Q, QElemType *e)
 {
     if(Q->front == Q->rear)                                //判断队列是否为空
         return ERROR;
     *e = Q->date[Q->front];                                //将队头元素取出
     Q->front = (Q->front + ) % MAXSIZE;                //队头后移
     return OK;
 }

 /*获取队列的长度*/
 int LengthQue(SqQueue Q)
 {
     return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
 }

 void main()
 {
     SqQueue Q;            //创建队Q
     int e;                //入队与出队的元素

     while(true)
     {
         printf("请选择对顺序栈的操作：\n");
         printf("1.初始化\n");
         printf("2.入队\n");
         printf("3.出队\n");
         printf("4.队列长度\n");
         printf("5.退出\n");
         int a;
         scanf("%d", &a);
         switch(a)
         {
             case :
                 if(InitQue(&Q))
                     printf("初始化成功\n");
                 else
                     printf("初始化失败\n");
                 break;
             case :
                 printf("请输入入队的元素：");
                 scanf("%d", &e);
                 if(EnQueue(&Q, e))
                     printf("入队成功\n");
                 else
                     printf("入队失败\n");
                 break;
             case :
                 if(DeQueue(&Q, &e))
                     printf("出队的元素为：%d\n",e);
                 else
                     printf("队空\n");
                 break;
             case :
                 printf("当前队列长度为：%d\n",LengthQue(Q));
                 break;
             case :
                 return;
             default:
                 printf("选择错误\n");
                 break;
         }
     }
 }

链式队列

 #include<stdio.h>
 #include<malloc.h>
 typedef int QElemType;                    //队列的结点元素类型
 typedef int Status;                        //函数返回值类型
 #define OK 1                            //操作成功返回值
 #define ERROR 0                            //操作失败返回值

 typedef struct QNode                    //结点结构体
 {
     QElemType date;                        //结点数据
     struct QNode *next;                    //结点指针
 }QNode, *LinkQuePtr;                            //结点名

 typedef struct                            //链队结构体
 {
     LinkQuePtr front;                    //队头结点
     LinkQuePtr rear;                    //队尾结点
 }LinkQue;                                //队名

 LinkQuePtr head = (LinkQuePtr)malloc(sizeof(QNode));                        //头结点

 /*链队的初始化*/
 Status InitQue(LinkQue *Q)
 {
     Q->front = head;                    //使头结点指向空
     Q->rear = head;                        //使尾结点指向空
     return OK;
 }

 /*链队的入队操作*/
 Status EnQueue(LinkQue *Q, QElemType e)
 {
     LinkQuePtr s = (LinkQuePtr)malloc(sizeof(QNode));            //申请新结点空间
     if(!s)
         return ERROR;
     s->date = e;                        //新结点的数据等于e
     s->next = NULL;                        //新结点的指针指向空
     Q->rear->next = s;                    //原队尾结点的指针指向新结点
     Q->rear = s;                        //队尾指针指向新结点（使新结点成为队尾结点）
     return OK;
 }

 /*链队的出队操作*/
 Status DeQueue(LinkQue *Q, QElemType *e)
 {
     if(Q->front == Q->rear)                //判断队列是否为空
         return ERROR;
     LinkQuePtr s = (LinkQuePtr)malloc(sizeof(QNode));        //申请结点空间s
     s = Q->front->next;                    //s结点等于队头结点（头指针所指向的结点）
     *e = s->date;                        //e等于s结点的数据域
     Q->front->next = s->next;            //头结点的指针指向s结点的下一结点（使s结点的下一结点成为队头元素）
     if(Q->rear == s)                    //判断s是否为队尾元素，若是，说明队列中仅有一个结点
         Q->rear = Q->front;                //使队尾结点指向头结点
     free(s);                            //释放s结点
     return OK;
 }

 void main()
 {
     LinkQue Q;            //创建队Q
     int e;                //入队与出队的元素

     while(true)
     {
         printf("请选择对顺序栈的操作：\n");
         printf("1.初始化\n");
         printf("2.入队\n");
         printf("3.出队\n");
 //        printf("3.遍历\n");
         printf("4.退出\n");
         int a;
         scanf("%d", &a);
         switch(a)
         {
             case :
                 if(InitQue(&Q))
                     printf("初始化成功\n");
                 else
                     printf("初始化失败\n");
                 break;
             case :
                 printf("请输入入队的元素：");
                 scanf("%d", &e);
                 if(EnQueue(&Q, e))
                     printf("入队成功\n");
                 else
                     printf("入队失败\n");
                 break;
             case :
                 if(DeQueue(&Q, &e))
                     printf("出队的元素为：%d\n",e);
                 else
                     printf("队空\n");
                 break;
             case :
                 return;
             default:
                 printf("选择错误\n");
                 break;
         }
     }
 }