队列----定义和实现

1、队列的定义

队列(Queue)：也是运算受限的线性表。是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的一端front进行插入，而在另一端rear进行删除。
    队首(front) ：允许进行删除的一端称为队首。
    队尾(rear) ：允许进行插入的一端称为队尾。
　　 例如：排队购物。操作系统中的作业排队。先进入队列的成员总是先离开队列。

        队列中没有元素时称为空队列。在空队列中依次加入元素a1, a2, …, an之后，a1是队首元素，an是队尾元素。显然退出队列的次序也只能是a1, a2, …, an ，即队列的修改是依先进先出的原则进行的，如图所示。

2 、队列的抽象数据类型定义
ADT Queue{
数据对象：D ={ ai|ai∈ElemSet,  i=1, 2, …, n, n >= 0 }

数据关系：R = {<ai-1, ai> | ai-1, ai∈D,  i=2,3,…,n }
       约定a1端为队首，an端为队尾。
基本操作：
Create()：创建一个空队列；
EmptyQue()：若队列为空，则返回true ，否则返回flase ；

FullQue();若队列为满，则返回true ，否则返回flase ；
⋯⋯
InsertQue(x) ：向队尾插入元素x；
DeleteQue(x) ：删除队首元素x；
} ADT Queue

3、队列的表示和实现

队列可以由三种方式实现：静态数组队列、动态数组队列和链式队列。

(1)静态数组队列（循环数组队列实现）

[cpp]  view plain  copy

 print ?

1. 循环队列可以更简单防止伪溢出的发生，但队列大小是固定的。  
2. /* 队列的顺序存储结构(循环队列) */  
3. #define MAX_QSIZE 5 /* 最大队列长度+1 */  
4. typedef struct  
5. {  
6.   QElemType *base; /* 初始化的动态分配存储空间 */  
7.   int front; /* <span style="color:#ff0000;">头指针，若队列不空，指向队列头元素</span> */  
8.   int rear;  /* <span style="color:#cc0000;">尾指针，若队列不空，指向队列尾元素的下一个位置</span> */  
9. }SqQueue;  
10.    
11. /* 循环队列的基本操作(9个) */  
12. void InitQueue(SqQueue *Q)  
13. { /* 构造一个空队列Q */  
14.   Q->base=malloc(MAX_QSIZE*sizeof(QElemType));  
15.   if(!Q->base) /* 存储分配失败 */  
16.     exit(OVERFLOW);  
17.   Q->front=Q->rear=0;/*空队列*/  
18. }  
19.    
20. void DestroyQueue(SqQueue *Q)  
21. { /* 销毁队列Q，Q不再存在 */  
22.   if(Q->base)  
23.     free(Q->base);  
24.   Q->base=NULL;  
25.   Q->front=Q->rear=0;  
26. }  
27.    
28. void ClearQueue(SqQueue *Q)  
29. { /* 将Q清为空队列 */  
30.   Q->front=Q->rear=0;  
31. }  
32.    
33. Status QueueEmpty(SqQueue Q)  
34. { /* 若队列Q为空队列，则返回TRUE；否则返回FALSE */  
35.   if(Q.front==Q.rear) /* 队列空的标志 */  
36.     return TRUE;  
37.   else  
38.     return FALSE;  
39. }  
40.    
41. int QueueLength(SqQueue Q)  
42. { /* 返回Q的元素个数，即队列的长度 */  
43.   return(Q.rear-Q.front+MAX_QSIZE)%MAX_QSIZE;  
44. }  
45.    
46. Status GetHead(SqQueue Q,QElemType *e)  
47. { /* 若队列不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR */  
48.   if(Q.front==Q.rear) /* 队列空 */  
49.     return ERROR;  
50.   *e=Q.base[Q.front];  
51.   return OK;  
52. }  
53.    
54. Status EnQueue(SqQueue *Q,QElemType e)  
55. { /* 插入元素e为Q的新的队尾元素 */  
56.   if((Q->rear+1)%MAX_QSIZE==Q->front) /* 队列满 */  
57.     return ERROR;  
58.   Q->base[Q->rear]=e;  
59.   Q->rear=(Q->rear+1)%MAX_QSIZE;  
60.   return OK;  
61. }  
62.    
63. Status DeQueue(SqQueue *Q,QElemType *e)  
64. { /* 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR */  
65.   if(Q->front==Q->rear) /* 队列空 */  
66.     return ERROR;  
67.   *e=Q->base[Q->front];  
68.   Q->front=(Q->front+1)%MAX_QSIZE;  
69.   return OK;  
70. }  
71.    
72. void QueueTraverse(SqQueue Q,void(*vi)(QElemType))  
73. { /* 从队头到队尾依次对队列Q中每个元素调用函数vi() */  
74.   int i;  
75.   i=Q.front;  
76.   while(i!=Q.rear)  
77.   {  
78.     vi(Q.base[i]);  
79.     i=(i+1)%MAX_QSIZE;  
80.   }  
81.   printf("\n");  
82. }  

(2)动态数组队列

[cpp]  view plain  copy

 print ?

1.   

(3)链式队列

[cpp]  view plain  copy

 print ?

1. 单链队列  
2. 单链队列使用链表作为基本数据结果，所以不存在伪溢出的问题，队列长度也没有限制。但插入和读取的时间代价较高  
3. /* 单链队列——队列的链式存储结构 */  
4. typedef struct QNode  
5. {  
6.   QElemType data;  
7.   struct QNode *next;  
8. }QNode,*QueuePtr;  
9.    
10. typedef struct  
11. {  
12.   QueuePtr front,rear; /* 队头、队尾指针 */  
13. }LinkQueue;  
14.    
15. /* 链队列的基本操作(9个) */  
16. void InitQueue(LinkQueue *Q)  
17. { /* 构造一个空队列Q */  
18.   Q->front=Q->rear=malloc(sizeof(QNode));  
19.   if(!Q->front)  
20.     exit(OVERFLOW);  
21.   Q->front->next=NULL;  
22. }  
23.    
24. void DestroyQueue(LinkQueue *Q)  
25. { /* 销毁队列Q(无论空否均可) */  
26.   while(Q->front)  
27.   {  
28.     Q->rear=Q->front->next;  
29.     free(Q->front);  
30.     Q->front=Q->rear;  
31.   }  
32. }  
33.    
34. void ClearQueue(LinkQueue *Q)  
35. { /* 将Q清为空队列 */  
36.   QueuePtr p,q;  
37.   Q->rear=Q->front;  
38.   p=Q->front->next;  
39.   Q->front->next=NULL;  
40.   while(p)  
41.   {  
42.     q=p;  
43.     p=p->next;  
44.     free(q);  
45.   }  
46. }  
47.    
48. Status QueueEmpty(LinkQueue Q)  
49. { /* 若Q为空队列，则返回TRUE，否则返回FALSE */  
50.   if(Q.front->next==NULL)  
51.     return TRUE;  
52.   else  
53.     return FALSE;  
54. }  
55.    
56. int QueueLength(LinkQueue Q)  
57. { /* 求队列的长度 */  
58.   int i=0;  
59.   QueuePtr p;  
60.   p=Q.front;  
61.   while(Q.rear!=p)  
62.   {  
63.     i++;  
64.     p=p->next;  
65.   }  
66.   return i;  
67. }  
68.    
69. Status GetHead_Q(LinkQueue Q,QElemType *e)  
70. { /* 若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR */  
71.   QueuePtr p;  
72.   if(Q.front==Q.rear)  
73.     return ERROR;  
74.   p=Q.front->next;  
75.   *e=p->data;  
76.   return OK;  
77. }  
78.    
79. void EnQueue(LinkQueue *Q,QElemType e)  
80. { /* 插入元素e为Q的新的队尾元素 */  
81.   QueuePtr p=malloc(sizeof(QNode));  
82.   if(!p) /* 存储分配失败 */  
83.     exit(OVERFLOW);  
84.   p->data=e;  
85.   p->next=NULL;  
86.   Q->rear->next=p;  
87.   Q->rear=p;  
88. }  
89.    
90. Status DeQueue(LinkQueue *Q,QElemType *e)  
91. { /* 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR */  
92.   QueuePtr p;  
93.   if(Q->front==Q->rear)  
94.     return ERROR;  
95.   p=Q->front->next;  
96.   *e=p->data;  
97.   Q->front->next=p->next;  
98.   if(Q->rear==p)  
99.     Q->rear=Q->front;  
100.   free(p);  
101.   return OK;  
102. }  
103.    
104. void QueueTraverse(LinkQueue Q,void(*vi)(QElemType))  
105. { /* 从队头到队尾依次对队列Q中每个元素调用函数vi() */  
106.   QueuePtr p;  
107.   p=Q.front->next;  
108.   while(p)  
109.   {  
110.     vi(p->data);  
111.     p=p->next;  
112.   }  
113.   printf("\n");  
114. }