顺序队列表示与操作实现

准备条件:

  1. #include "stdio.h"
  2. #include "stdlib.h"
  4. #include "math.h"
  5. #include "time.h"
  7. #define OK 1
  8. #define ERROR 0
  9. #define TRUE 1
  10. #define FALSE 0
  11. #define MAXSIZE 20 /* 存储空间初始分配量 */
  13. typedef int Status;
  14. typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */
  16. /* 循环队列的顺序存储结构 */
  17. typedef struct
  18. {
  19.     QElemType data[MAXSIZE];
  20.     int front;        /* 头指针 */
  21.     int rear;        /* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
  22. }SqQueue;

调用方式:

  1. int main(int argc, const char * argv[]) {
  2.     // insert code here...
  3.     printf("001--顺序队列表示与操作实现\n");
  5.     Status j;
  6.     int i=0,l;
  7.     QElemType d;
  8.     SqQueue Q;
  9.     InitQueue(&Q);
  10.     printf("初始化队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
  12.     printf("入队:\n");
  13.     while (i < 10) {
  14.         EnQueue(&Q, i);
  15.         i++;
  16.     }
  17.     QueueTraverse(Q);
  18.     printf("队列长度为: %d\n",QueueLength(Q));
  19.     printf("现在队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
  20.     printf("出队:\n");
  22.    //出队
  23.     DeQueue(&Q, &d);
  24.     printf("出队的元素:%d\n",d);
  25.     QueueTraverse(Q);
  27.     //获取队头
  28.     j=GetHead(Q,&d);
  29.     if(j)
  30.         printf("现在队头元素为: %d\n",d);
  31.     ClearQueue(&Q);
  32.     printf("清空队列后, 队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
  33.     return 0;
  34. }

1. 初始化一个空队列Q

  1. Status InitQueue(SqQueue *Q){
  2.     Q->front = 0;
  3.     Q->rear = 0;
  4.     return OK;
  5. }

2. 将队列清空

  1. Status ClearQueue(SqQueue *Q){
  3.     Q->front = Q->rear = 0;
  4.     return OK;
  5. }

3. 若队列Q为空队列,则返回TRUR,否则返回FALSE;

  1. //3 若队列Q为空队列,则返回TRUR,否则返回FALSE;
  2. Status QueueEmpty(SqQueue Q){
  3.     //队空标记
  4.     if (Q.front == Q.rear)
  5.         return TRUE;
  6.     else
  7.         return FALSE;
  8. }

4. 返回Q的元素个数,也就是队列的当前长度

  1. //6.4 返回Q的元素个数,也就是队列的当前长度
  2. int QueueLength(SqQueue Q){
  3.     return (Q.rear - Q.front + MAXSIZE)%MAXSIZE;
  4. }

5. 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR;

  1. Status GetHead(SqQueue Q,QElemType *e){
  2.     //队列已空
  3.     if (Q.front == Q.rear)
  4.         return ERROR;
  6.     *e = Q.data[Q.front];
  7.     return OK;
  9. }

6. 若队列未满,则插入元素e为新队尾元素

  1. Status EnQueue(SqQueue *Q,QElemType e){
  3.     //队列已满
  4.     if((Q->rear+1)%MAXSIZE == Q->front)
  5.         return ERROR;
  7.     //将元素e赋值给队尾
  8.     Q->data[Q->rear] = e;
  10.     //rear指针向后移动一位,若到最后则转到数组头部;
  11.     Q->rear = (Q->rear+1)%MAXSIZE;
  13.     return OK;
  14. }

7. 若队列不空,则删除Q中队头的元素,用e返回值

  1. Status DeQueue(SqQueue *Q,QElemType *e){
  3.     //判断队列是否为空
  4.     if (Q->front == Q->rear) {
  5.         return ERROR;
  6.     }
  8.     //将队头元素赋值给e
  9.     *e = Q->data[Q->front];
  11.     //front 指针向后移动一位,若到最后则转到数组头部
  12.     Q->front = (Q->front+1)%MAXSIZE;
  14.     return OK;
  15. }

8. 从队头到队尾依次对队列的每个元素数组

  1. Status QueueTraverse(SqQueue Q){
  2.     int i;
  3.     i = Q.front;
  4.     while ((i+Q.front) != Q.rear) {
  5.         printf("%d   ",Q.data[i]);
  6.         i = (i+1)%MAXSIZE;
  7.     }
  8.     printf("\n");
  9.     return OK;
  10. }

链队列表示与操作实现

准备条件

  1. #define OK 1
  2. #define ERROR 0
  3. #define TRUE 1
  4. #define FALSE 0
  5. #define MAXSIZE 20 /* 存储空间初始分配量 */
  7. typedef int Status;
  9. typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */
  11. typedef struct QNode    /* 结点结构 */
  12. {
  13.     QElemType data;
  14.     struct QNode *next;
  15. }QNode,*QueuePtr;
  17. typedef struct            /* 队列的链表结构 */
  18. {
  19.     QueuePtr front,rear; /* 队头、队尾指针 */
  20. }LinkQueue;

调用示例:

  1. int main(int argc, const char * argv[]) {
  2.     // insert code here...
  3.     printf("链队列的表示与操作!\n");
  5.     Status iStatus;
  6.     QElemType d;
  7.     LinkQueue q;
  9.     //1.初始化队列q
  10.     iStatus = InitQueue(&q);
  12.     //2. 判断是否创建成
  13.     if (iStatus) {
  14.         printf("成功地构造了一个空队列\n");
  15.     }
  17.     //3.判断队列是否为空
  18.     printf("是否为空队列?%d (1:是 0:否)\n",QueueEmpty(q));
  20.     //4.获取队列的长度
  21.     printf("队列的长度为%d\n",QueueLength(q));
  23.     //5.插入元素到队列中
  24.     EnQueue(&q, -3);
  25.     EnQueue(&q, 6);
  26.     EnQueue(&q, 12);
  28.     printf("队列的长度为%d\n",QueueLength(q));
  29.     printf("是否为空队列?%d (1:是 0:否)\n",QueueEmpty(q));
  31.     //6.遍历队列
  32.     printf("队列中的元素如下:\n");
  33.     QueueTraverse(q);
  35.     //7.获取队列头元素
  36.     iStatus = GetHead(q, &d);
  37.     if (iStatus == OK) {
  38.         printf("队头元素是:%d\n",d);
  39.     }
  41.     //8.删除队头元素
  42.     iStatus =DeQueue(&q, &d);
  43.     if (iStatus == OK) {
  44.         printf("删除了的队头元素为:%d\n",d);
  45.     }
  47.     //9.获取队头元素
  48.     iStatus = GetHead(q, &d);
  49.     if (iStatus == OK) {
  50.         printf("新的队头元素为:%d\n",d);
  51.     }
  53.     //10.清空队列
  54.     ClearQueue(&q);
  56.     //11.销毁队列
  57.     DestoryQueue(&q);
  59.     return 0;
  60. }

1. 初始化队列

  1. Status InitQueue(LinkQueue *Q){
  2.     //1. 头/尾指针都指向新生成的结点
  3.     Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
  4.     //2.判断是否创建新结点成功与否
  5.     if (!Q->front) {
  6.         return ERROR;
  7.     }
  8.     //3.头结点的指针域置空
  9.     Q->front->next = NULL;   
  10.     return OK;
  11. }

2. 销毁队列Q

  1. Status DestoryQueue(LinkQueue *Q){
  2.     //遍历整个队列,销毁队列的每个结点
  3.     while (Q->front) {
  4.         Q->rear = Q->front->next;
  5.         free(Q->front);
  6.         Q->front = Q->rear;
  7.     }
  8.     return OK;
  9. }

3. 将队列Q置空

  1. Status ClearQueue(LinkQueue *Q){
  3.     QueuePtr p,q;
  4.     Q->rear = Q->front;
  5.     p = Q->front->next;
  6.     Q->front->next = NULL;
  8.     while (p) {
  9.         q = p;
  10.         p = p->next;
  11.         free(q);
  12.     }
  13.     return OK;
  14. }

4. 判断队列Q是否为空

  1. Status QueueEmpty(LinkQueue Q){
  2.     if (Q.front == Q.rear)
  3.         return TRUE;
  4.     else
  5.         return FALSE;
  6. }

5. 获取队列长度

  1. int QueueLength(LinkQueue Q){
  2.     int i= 0;
  3.     QueuePtr p;
  4.     p = Q.front;
  5.     while (Q.rear != p) {
  6.         i++;
  7.         p = p->next;
  8.     }
  9.     return i;
  10. }

6. 插入元素e为队列Q的新元素

  1. Status EnQueue(LinkQueue *Q,QElemType e){
  3.     //为入队元素分配结点空间,用指针s指向;
  4.     QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
  5.     //判断是否分配成功
  6.     if (!s) {
  7.          return ERROR;
  8.     }
  10.     //将新结点s指定数据域.
  11.     s->data = e;
  12.     s->next = NULL;
  14.     //将新结点插入到队尾
  15.     Q->rear->next = s;
  17.     //修改队尾指针
  18.     Q->rear = s;
  20.     return OK;
  21. }

7. 出队列

  1. Status DeQueue(LinkQueue *Q,QElemType *e){
  2.     QueuePtr p;
  4.     //判断队列是否为空;
  5.     if (Q->front == Q->rear) {
  6.         return ERROR;
  7.     }
  8.     //将要删除的队头结点暂时存储在p
  9.     p = Q->front->next;
  11.     //将要删除的队头结点的值赋值给e
  12.     *e = p->data;
  14.     //将原队列头结点的后继p->next 赋值给头结点后继
  15.     Q->front->next = p ->next;
  17.     //若队头就是队尾,则删除后将rear指向头结点.
  18.     if(Q->rear == p) Q->rear = Q->front;
  20.     free(p);
  22.     return OK;
  23. }

8. 获取队头元素

  1. Status GetHead(LinkQueue Q,QElemType *e){   
  2.     //队列非空
  3.     if (Q.front != Q.rear) {
  4.         //返回队头元素的值,队头指针不变
  5.         *e =  Q.front->next->data;
  6.         return TRUE;
  7.     }
  8.     return  FALSE;    
  9. }

9. 遍历队列

  1. Status QueueTraverse(LinkQueue Q){
  3.     QueuePtr p;
  4.     p = Q.front->next;
  5.     while (p) {
  6.         printf("%d ",p->data);
  7.         p = p->next;
  8.     }
  9.     printf("\n");
  10.     return OK;
  11. }