学习笔记：队列
第二部分 队列
1. 队列的定义
队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
队列是一种先进先出的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。
2. 队列的抽象数据类型
ADT 队列（Queue）
Data
同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。
Operation
InitQueue(&Q):初始化操作，建立一个空队列Q。
DestoryQueue(&Q):若队列Q存在，则销毁它。
ClearQueue(&Q):将队列Q清空。
QueueEmpty(Q):若队列Q为空，返回true，否则返回false。
GetHead(Q,&e):若队列存在且非空，用e返回队列Q的队头元素。
EnQueue(&Q,e):若队列Q存在，插入新元素e到队列Q并称为对尾元素。
DeQueue(&Q,&e):删除队列Q中队头元素，并用e返回其值。
QueueLength(Q):返回队列Q的元素个数。
endADT
3. 循环队列（顺序存储结构）
我们把队列的这种头尾相接的顺序存储结构称为循环队列。
//队列的顺序存储结构
typedef struct{
QElemType *base; //初始化的动态分配存储空间
int front; //队头索引
int rear; //对尾索引
}SqQueue;
循环队列基本操作：
队列的初始化：
Status InitQueue(SqQueue &Q){
Q.base =(QElemType *)malloc(MAXQSIZE*sizeof(SqQueue));
if(!Q.base)
exit(OVERFLOW);
Q.front = Q.front = 0;
return OK;
}
队列的销毁：
Status DestoryQueue(SqQueue &Q){
while(Q.front!=Q.rear){
free(&Q.base[Q.front]);
Q.front = (Q.front + 1) % MAXQSIZE;
}
return OK;
}
队列的清空：
Status ClearQueue(SqQueue &Q){
Q.front=Q.rear=0;
return OK;
}
判断队列是否为空：
Status QueueEmpty(SqQueue Q){
if(Q.front==Q.rear) // 队列空的标志
return TRUE;
else
return FALSE;
}
返回队头元素：
Status GetHead(SqQueue Q,QElemType &e){
if(Q.front == Q.rear)
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;
}
返回队列长度：
int QueueLength(SqQueue Q){
return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}
测试总代码：
#include<stdio.h>
#include<stdlib.h>
#define MAXQSIZE 10 //最大队列长度
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
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(SqQueue));
if(!Q.base)
exit(OVERFLOW);
Q.front = Q.front = 0;
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 GetHead(SqQueue Q,QElemType &e){
if(Q.front == Q.rear)
return ERROR;
e = Q.base[Q.front];
return OK;
}
Status ClearQueue(SqQueue &Q){
Q.front=Q.rear=0;
return OK;
}
Status QueueEmpty(SqQueue Q){
if(Q.front==Q.rear) // 队列空的标志
return TRUE;
else
return FALSE;
}
int QueueLength(SqQueue Q){
return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}
Status DestoryQueue(SqQueue &Q){
while(Q.front!=Q.rear){
free(&Q.base[Q.front]);
Q.front = (Q.front + 1) % MAXQSIZE;
}
return OK;
}
Status visit(QElemType c)
{
printf("%d ",c);
return OK;
}
//从队头到队尾依次对队列Q中每个元素输出
Status QueueTraverse(SqQueue Q)
{
int i;
i=Q.front;
while((i+Q.front)!=Q.rear)
{
visit(Q.base[i]);
i=(i+1)%MAXQSIZE;
}
printf("\n");
return OK;
}
int main()
{
Status j;
int i=0,l;
QElemType d;
SqQueue Q;
InitQueue(Q);
printf("初始化队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
printf("请输入整型队列元素(不超过%d个),-1为提前结束符: ",MAXQSIZE-1);
do
{
/* scanf("%d",&d); */
d=i+100;
if(d==-1)
break;
i++;
EnQueue(Q,d);
}while(i<MAXQSIZE-1);
printf("队列长度为: %d\n",QueueLength(Q));
printf("现在队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
printf("连续%d次由队头删除元素,队尾插入元素:\n",MAXQSIZE);
for(l=1;l<=MAXQSIZE;l++)
{
DeQueue(Q,d);
printf("删除的元素是%d,插入的元素:%d \n",d,l+1000);
/* scanf("%d",&d); */
d=l+1000;
EnQueue(Q,d);
}
l=QueueLength(Q);
printf("现在队列中的元素为: \n");
QueueTraverse(Q);
printf("共向队尾插入了%d个元素\n",i+MAXQSIZE);
if(l-2>0)
printf("现在由队头删除%d个元素:\n",l-2);
while(QueueLength(Q)>2)
{
DeQueue(Q,d);
printf("删除的元素值为%d\n",d);
}
j=GetHead(Q,d);
if(j)
printf("现在队头元素为: %d\n",d);
ClearQueue(Q);
printf("清空队列后, 队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
return 0;
}
运行结果：
4. 队列的链式存储结构及实现
队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列。
为了操作方便，我们将队头指针指向链队列的头结点，而队尾指针指向终端结点。
空队列时，front和rear都指向头节点。
typedef struct QNode
{
QElemType data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
QueuePtr front,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)
{
QueuePtr p,q;
Q->rear=Q->front;
p=Q->front->next;
Q->front->next=NULL;
while(p)
{
q=p;
p=p->next;
free(q);
}
return OK;
}
判断队列是否为空：
Status QueueEmpty(LinkQueue Q)
{
if(Q.front==Q.rear)
return TRUE;
else
return FALSE;
}
返回队头元素：
Status GetHead(LinkQueue Q,QElemType &e)
{
QueuePtr p;
if(Q.front==Q.rear)
return ERROR;
p=Q.front->next;
e=p->data;
return OK;
}
入队：
Status EnQueue(LinkQueue &Q,QElemType e)
{
QueuePtr s=(QueuePtr)malloc(sizeof(QNode));
if(!s)
exit(OVERFLOW);
s->data=e;
s->next=NULL;
Q.rear->next=s;
Q.rear=s;
return OK;
}
出队：
Status DeQueue(LinkQueue &Q,QElemType &e)
{
QueuePtr p;
if(Q.front==Q.rear)
return ERROR;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
free(p);
return OK;
}
返回队列长度：
int QueueLength(LinkQueue Q)
{
int i=0;
QueuePtr p;
p=Q.front;
while(Q.rear!=p)
{
i++;
p=p->next;
}
return i;
}
测试总代码：
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int Status;
typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */
typedef struct QNode /* 结点结构 */
{
QElemType data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct /* 队列的链表结构 */
{
QueuePtr front,rear; /* 队头、队尾指针 */
}LinkQueue;
Status visit(QElemType c)
{
printf("%d ",c);
return OK;
}
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)
{
QueuePtr p,q;
Q.rear=Q.front;
p=Q.front->next;
Q.front->next=NULL;
while(p)
{
q=p;
p=p->next;
free(q);
}
return OK;
}
Status QueueEmpty(LinkQueue Q)
{
if(Q.front==Q.rear)
return TRUE;
else
return FALSE;
}
int QueueLength(LinkQueue Q)
{
int i=0;
QueuePtr p;
p=Q.front;
while(Q.rear!=p)
{
i++;
p=p->next;
}
return i;
}
Status GetHead(LinkQueue Q,QElemType &e)
{
QueuePtr p;
if(Q.front==Q.rear)
return ERROR;
p=Q.front->next;
e=p->data;
return OK;
}
Status EnQueue(LinkQueue &Q,QElemType e)
{
QueuePtr s=(QueuePtr)malloc(sizeof(QNode));
if(!s)
exit(OVERFLOW);
s->data=e;
s->next=NULL;
Q.rear->next=s;
Q.rear=s;
return OK;
}
Status DeQueue(LinkQueue &Q,QElemType &e)
{
QueuePtr p;
if(Q.front==Q.rear)
return ERROR;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
free(p);
return OK;
}
Status QueueTraverse(LinkQueue Q)
{
QueuePtr p;
p=Q.front->next;
while(p)
{
visit(p->data);
p=p->next;
}
printf("\n");
return OK;
}
int main()
{
int i;
QElemType d;
LinkQueue q;
i=InitQueue(q);
if(i)
printf("成功地构造了一个空队列!\n");
printf("是否空队列？%d(1:空 0:否) ",QueueEmpty(q));
printf("队列的长度为%d\n",QueueLength(q));
EnQueue(q,-5);
EnQueue(q,5);
EnQueue(q,10);
printf("插入3个元素(-5,5,10)后,队列的长度为%d\n",QueueLength(q));
printf("是否空队列？%d(1:空 0:否) ",QueueEmpty(q));
printf("队列的元素依次为：");
QueueTraverse(q);
i=GetHead(q,d);
if(i==OK)
printf("队头元素是：%d\n",d);
DeQueue(q,d);
printf("删除了队头元素%d\n",d);
i=GetHead(q,d);
if(i==OK)
printf("新的队头元素是：%d\n",d);
ClearQueue(q);
printf("清空队列后,q.front=%u q.rear=%u q.front->next=%u\n",q.front,q.rear,q.front->next);
DestroyQueue(q);
printf("销毁队列后,q.front=%u q.rear=%u\n",q.front, q.rear);
return 0;
}
运行结果：
5. 总结：
（1）对于循环队列与链队列的比较，从时间上，其实它们的基本操作都是常数时间，即都为0(1)的，不过循环队列是事先申请好空间，使用期间不释放，而对于链队列，每次申请和释放结点也会存在一些时间开销,如果入队出队频繁，则两者还是有细微差异。对于空间上来说，循环队列必须有一个固定的长度，所以就有了存储元素个数和空间浪费的问题。而链队列不存在这个问题，尽管它需要一个指针域，会产生一些空间上的开销，但也可以接受。所以在空间上，链队列更加灵活。
总的来说，在可以确定队列长度最大值的情况下，建议用循环队列，如果你无法预估队列的长度时，则用链队列。
（2）
栈和队列，它们都是特殊的线性表,只不过对插入和删除操作做了限制。
栈(stack)是限定仅在表尾进行插入和删除操作的线性表。
队列（queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表。
它们均可以用线性表的顺序存储结构来实现，但都存在着顺序存储的一些弊端。
因此它们各自有各自的技巧来解决这个问题。
对于队列来说，为了避免数组插入和删除时需要移动数据，于是就引入了循环队列，使得队头和队尾可以在数组中循环变化。解决了移动数据的时间损耗，使得本来插入和删除是O(n)的时间复杂度变成了0(1)。
它们也都可以通过链式存储结构来实现，实现原则上与线性表基本相同。
但行好事，莫问前程。
不忘初心，方得始终。
做好自己，温暖且积极！！
244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
