链队列

来源：http://blog.csdn.net/hopeyouknow/article/details/6736987

队列也是常用的数据结构之一，下面给出一个链式队列的实现~~

头文件Queue.h

[cpp] view plaincopy
  1. #ifndef Queue_H  
  2. #define Queue_H  
  3.   
  4. typedef int Item;  
  5. typedef struct node * PNode;  
  6. typedef struct node  
  7. {  
  8.     Item data;  
  9.     PNode next;  
  10. }Node;  
  11.   
  12. typedef struct  
  13. {  
  14.     PNode front;  
  15.     PNode rear;  
  16.     int size;  
  17. }Queue;  
  18.   
  19. /*构造一个空队列*/  
  20. Queue *InitQueue();  
  21.   
  22. /*销毁一个队列*/  
  23. void DestroyQueue(Queue *pqueue);  
  24.   
  25. /*清空一个队列*/  
  26. void ClearQueue(Queue *pqueue);  
  27.   
  28. /*判断队列是否为空*/  
  29. int IsEmpty(Queue *pqueue);  
  30.   
  31. /*返回队列大小*/  
  32. int GetSize(Queue *pqueue);  
  33.   
  34. /*返回队头元素*/  
  35. PNode GetFront(Queue *pqueue,Item *pitem);  
  36.   
  37. /*返回队尾元素*/  
  38. PNode GetRear(Queue *pqueue,Item *pitem);  
  39.   
  40. /*将新元素入队*/  
  41. PNode EnQueue(Queue *pqueue,Item item);  
  42.   
  43. /*队头元素出队*/  
  44. PNode DeQueue(Queue *pqueue,Item *pitem);  
  45.   
  46. /*遍历队列并对各数据项调用visit函数*/  
  47. void QueueTraverse(Queue *pqueue,void (*visit)());  
  48.   
  49. #endif  


实现代码Queue.c如下:

[cpp] view plaincopy
  1. #include"Queue.h"  
  2. #include<malloc.h>  
  3. #include<stdio.h>  
  4.   
  5. /*构造一个空队列*/  
  6. Queue *InitQueue()  
  7. {  
  8.     Queue *pqueue = (Queue *)malloc(sizeof(Queue));  
  9.     if(pqueue!=NULL)  
  10.     {  
  11.         pqueue->front = NULL;  
  12.         pqueue->rear = NULL;  
  13.         pqueue->size = 0;  
  14.     }  
  15.     return pqueue;  
  16. }  
  17.   
  18. /*销毁一个队列*/  
  19. void DestroyQueue(Queue *pqueue)  
  20. {  
  21.     if(IsEmpty(pqueue)!=1)  
  22.         ClearQueue(pqueue);  
  23.     free(pqueue);  
  24. }  
  25.   
  26. /*清空一个队列*/  
  27. void ClearQueue(Queue *pqueue)  
  28. {  
  29.     while(IsEmpty(pqueue)!=1)  
  30.     {  
  31.         DeQueue(pqueue,NULL);  
  32.     }  
  33.   
  34. }  
  35.   
  36. /*判断队列是否为空*/  
  37. int IsEmpty(Queue *pqueue)  
  38. {  
  39.     if(pqueue->front==NULL&&pqueue->rear==NULL&&pqueue->size==0)  
  40.         return 1;  
  41.     else  
  42.         return 0;  
  43. }  
  44.   
  45. /*返回队列大小*/  
  46. int GetSize(Queue *pqueue)  
  47. {  
  48.     return pqueue->size;  
  49. }  
  50.   
  51. /*返回队头元素*/  
  52. PNode GetFront(Queue *pqueue,Item *pitem)  
  53. {  
  54.     if(IsEmpty(pqueue)!=1&&pitem!=NULL)  
  55.     {  
  56.         *pitem = pqueue->front->data;  
  57.     }  
  58.     return pqueue->front;  
  59. }  
  60.   
  61. /*返回队尾元素*/  
  62.   
  63. PNode GetRear(Queue *pqueue,Item *pitem)  
  64. {  
  65.     if(IsEmpty(pqueue)!=1&&pitem!=NULL)  
  66.     {  
  67.         *pitem = pqueue->rear->data;  
  68.     }  
  69.     return pqueue->rear;  
  70. }  
  71.   
  72. /*将新元素入队*/  
  73. PNode EnQueue(Queue *pqueue,Item item)  
  74. {  
  75.     PNode pnode = (PNode)malloc(sizeof(Node));  
  76.     if(pnode != NULL)  
  77.     {  
  78.         pnode->data = item;  
  79.         pnode->next = NULL;  
  80.           
  81.         if(IsEmpty(pqueue))  
  82.         {  
  83.             pqueue->front = pnode;  
  84.         }  
  85.         else  
  86.         {  
  87.             pqueue->rear->next = pnode;  
  88.         }  
  89.         pqueue->rear = pnode;  
  90.         pqueue->size++;  
  91.     }  
  92.     return pnode;  
  93. }  
  94.   
  95. /*队头元素出队*/  
  96. PNode DeQueue(Queue *pqueue,Item *pitem)  
  97. {  
  98.     PNode pnode = pqueue->front;  
  99.     if(IsEmpty(pqueue)!=1&&pnode!=NULL)  
  100.     {  
  101.         if(pitem!=NULL)  
  102.             *pitem = pnode->data;  
  103.         pqueue->size--;  
  104.         pqueue->front = pnode->next;  
  105.         free(pnode);  
  106.         if(pqueue->size==0)  
  107.             pqueue->rear = NULL;  
  108.     }  
  109.     return pqueue->front;  
  110. }  
  111.   
  112. /*遍历队列并对各数据项调用visit函数*/  
  113. void QueueTraverse(Queue *pqueue,void (*visit)())  
  114. {  
  115.     PNode pnode = pqueue->front;  
  116.     int i = pqueue->size;  
  117.     while(i--)  
  118.     {  
  119.         visit(pnode->data);  
  120.         pnode = pnode->next;  
  121.     }  
  122.           
  123. }  


简单测试程序Test.c

[cpp] view plaincopy
  1. #include"Queue.h"  
  2. #include<stdio.h>  
  3. void print(Item i)  
  4. {  
  5.     printf("该节点元素为%d\n",i);  
  6. }  
  7. main()  
  8. {  
  9.     Queue *pq = InitQueue();  
  10.     int i,item;  
  11.     printf("0-9依次入队并输出如下：\n");  
  12.     for(i=0;i<10;i++)  
  13.     {  
  14.         EnQueue(pq,i);  
  15.         GetRear(pq,&item);  
  16.         printf("%d ",item);  
  17.     }  
  18.   
  19.     printf("\n从队头到队尾遍历并对每个元素执行print函数：\n");   
  20.     QueueTraverse(pq,print);  
  21.   
  22.     printf("队列中元素依次出队列并输出如下：\n");  
  23.     for(i=0;i<10;i++)  
  24.     {  
  25.         DeQueue(pq,&item);  
  26.         printf("%d ",item);  
  27.     }  
  28.     ClearQueue(pq);  
  29.     if(IsEmpty(pq))  
  30.         printf("\n将队列置空成功\n");  
  31.     DestroyQueue(pq);  
  32.     printf("队列已被销毁\n");  
  33. }  

 

 

方法二：

  1 /*******************************************************************************
  2 /* <PRE>
  3 /* 版权所有    : -
  4 /* 模块名      : 栈和队列
  5 /* 文件名      : lqueue.cpp
  6 /* 功能描述    : 链队列的表示与实现 
  7 /* 作者        : <xxx>
  8 /* 版本        : 1.0
  9 /* -----------------------------------------------------------------------------
 10 /* 备注        : -
 11 /* -----------------------------------------------------------------------------
 12 /* 修改记录    :
 13 /* 日 期        版本     修改人        修改内容
 14 /* 2011/01/01   1.0      <xxx>         创建
 15 /* </PRE>
 16 *******************************************************************************/
 17 #include <stdio.h>
 18 #include <stdlib.h>
 19 
 20 /******************************************************************************
 21 /* 数据类型和常量定义
 22 /******************************************************************************/
 23 #define OK           1
 24 #define ERROR        0
 25 #define OVERFLOW    -2
 26 
 27 typedef int Status;
 28 typedef int QElemType;
 29 
 30 
 31 /******************************************************************************
 32 /* 数据结构声明
 33 /******************************************************************************/
 34 /* 单链队列 - 队列的链式存储结构 */
 35 typedef struct QNode{
 36     QElemType data;
 37     struct QNode *next;
 38 } QNode, *QueuePtr;
 39 
 40 typedef struct {
 41     QueuePtr front; /* 队头指针 */
 42     QueuePtr rear;  /* 队尾指针 */
 43 } LinkQueue;
 44 
 45 
 46 /******************************************************************************
 47 /* 函数原型声明
 48 /******************************************************************************/
 49 /*队列操作函数*/
 50 Status InitQueue(LinkQueue &Q);
 51 Status DestroyQueue(LinkQueue &Q);
 52 Status ClearQueue(LinkQueue &Q);
 53 Status QueueEmpty(LinkQueue Q);
 54 int QueueLength(LinkQueue Q);
 55 Status GetHead(LinkQueue Q, QElemType &e);
 56 Status EnQueue(LinkQueue &Q, QElemType e);
 57 Status DeQueue(LinkQueue &Q, QElemType &e);
 58 
 59 
 60 /*******************************************************************************
 61 /* <FUNC>
 62 /* 函数名   : InitQueue
 63 /* 功能     : 构造空队列
 64 /* 参数     : -
 65 /* 返回值   : -
 66 /* 备注     : 构造一个空队列Q
 67 /* 作者     : <xxx>
 68 /* </FUNC>
 69 *******************************************************************************/
 70 Status InitQueue(LinkQueue &Q) {
 71     Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
 72     if (!Q.front) exit(OVERFLOW);
 73     Q.front->next = NULL;
 74     return OK;
 75 }
 76 
 77 /*******************************************************************************
 78 /* <FUNC>
 79 /* 函数名   : DestroyQueue
 80 /* 功能     : 销毁队列
 81 /* 参数     : -
 82 /* 返回值   : -
 83 /* 备注     : 销毁队列Q
 84 /* 作者     : <xxx>
 85 /* </FUNC>
 86 *******************************************************************************/
 87 Status DestroyQueue(LinkQueue &Q) {
 88     while (Q.front) {
 89         Q.rear = Q.front->next;
 90         free(Q.front);
 91         Q.front = Q.rear;
 92     }
 93     return OK;
 94 }
 95 
 96 /*******************************************************************************
 97 /* <FUNC>
 98 /* 函数名   : EnQueue
 99 /* 功能     : 入队列
100 /* 参数     : -
101 /* 返回值   : -
102 /* 备注     : 插入元素e为Q的新的队尾元素
103 /* 作者     : <xxx>
104 /* </FUNC>
105 *******************************************************************************/
106 Status EnQueue(LinkQueue &Q, QElemType e) {
107     struct QNode *p = (QueuePtr)malloc(sizeof(QNode));
108     if (!p) exit(OVERFLOW);
109     p->data = e; p->next = NULL;
110     Q.rear->next = p;
111     Q.rear = p;
112     return OK;
113 }
114 
115 /*******************************************************************************
116 /* <FUNC>
117 /* 函数名   : DeQueue
118 /* 功能     : 出队列
119 /* 参数     : -
120 /* 返回值   : -
121 /* 备注     : 若队列不空, 则删除Q的队头元素, 用e返回其值, 并返回OK; 否则返回ERROR
122 /* 作者     : <xxx>
123 /* </FUNC>
124 *******************************************************************************/
125 Status DeQueue(LinkQueue &Q, QElemType &e) {
126     struct QNode *p = NULL;
127     if (Q.front == Q.rear) return ERROR;
128     p = Q.front->next;
129     e = p->data;
130     Q.front->next = p->next;
131     if (Q.rear == p) Q.rear = Q.front;
132     free(p);
133     return OK;
134 }
135 
136 
137 /*******************************************************************************
138 /* <FUNC>
139 /* 函数名   : main
140 /* 功能     : 测试函数
141 /* 参数     : -
142 /* 返回值   : -
143 /* 备注     : -
144 /* 作者     : <xxx>
145 /* </FUNC>
146 *******************************************************************************/
147 void main()
148 {
149     LinkQueue Q;  QElemType e;
150     InitQueue(Q);
151     EnQueue(Q, 10);
152     EnQueue(Q, 20);
153     EnQueue(Q, 30);
154     if(OK == DeQueue(Q, e)) printf("%d\n", e);
155     if(OK == DeQueue(Q, e)) printf("%d\n", e);
156     if(OK == DeQueue(Q, e)) printf("%d\n", e);
157     if(OK == DeQueue(Q, e)) printf("%d\n", e);
158 }

参考：http://www.cnblogs.com/JCSU/articles/2005839.html

posted on 2013-08-21 14:38  猿人谷  阅读(499)  评论(0)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 猿人谷
Powered by .NET 9.0 on Kubernetes