大话数据结构之队列

一、队列的定义

大家用电脑时一定都经历过，机器有时候会处于疑似死机的状态，鼠标点什么似乎都没有用，双击任何快捷方式都不动弹。就当你失去耐心，打算reset时，突然它像酒醒了一样，把你刚才点击的所有操作全部都按顺序执行了一遍。这其实是因为操作系统中的多个程序因需要通过一个通道输出，而按先后次序排队等待造成的

再比如像移动、联通、电信等客服电话，客服人员与客户相比总是少数，在所有的客服人员都占线的情况下，客户会被要求等待，直到有某个客服人员空下来，才能让最先等待的客户接通电话。这里也是将所有当前拨打客服电话的客户进行了排队处理

操作系统和客服系统中，都是应用了一种数据结构来实现刚才提到的先进先出的排队功能，这就是队列

队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表

是一种先进先出（First In First Out）的线性表，简称FIFO。

允许插入的一端称为队尾
允许删除的一端称为对头

队列还有一些典型应用：键盘进行各种字母和数字的输入

显示器上如记事本软件上的输出

二、队列的抽象数据类型

ADT   队列(queue)

Data

   同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。

Operation

   InitQueue(*Q): 初始化操作.建立一个空队列Q。

   DestroyQueue(*Q): 若队列Q存在，則销毁它。

   ClearQueue(*Q): 将队列Q清空。

   QueueEmpty(Q): 若队列Q为空，返回true,否則返回 false。

   GetHead(Q, *e): 若队列Q存在且非空，用e返回队列Q的队头元素。

   EnQueue(*Q, e): 若队列Q存在，插入新元素e到队列Q中并成为队尾元素。

   DeQueue(*Q, *e): 删除队列Q中队头元素，并用e返回其值。

   QueueLength(Q): 返回队列Q的元素个数。

endADT

三、循环队列

1、队列顺序存储的不足

我们假设一个队列有n个元素，则顺序存储的队列需建立一个大于n的数组，并把队列的所有元素存储在数组的前n个单元，数组下标为0的一端即是对头

所谓的入队列操作，其实就是在队尾追加一个元素，不需要移动任何元素，因此时间复杂度为0(1)

与栈不同的是，队列元素的出列是在队头，即下标为0的位置，那也就意味着，队列中的所有元素都得向前移动，以保证队列的队头，也就是下标为0的位置不为空，此时时间复杂度为0(n)

可有时想想，为什么出队列时一定要全部移动呢，如果不去限制队列的元素必须存储在数组的前n个单元这一条件，出队的性能就会大大增加，也就是说，对头不需要一定在下标为0的位置

为了避免当只有一个元素时，对头和队尾重合使处理变得麻烦，所以引入两个指针，front指针指向对头元素，rear指针指向队尾元素的下一个位置，这样当front等于rear时，此队列不是还剩下一个元素，而是空队列

假设是长度为5的数组，初始状态，空队列如下左图所示，front 与rear指针均指向下标为0的位置。然后入队a1，a2，a3，a4，front指针依然指向下标为0位置，而rear指针指向下标为4的位置

出队a1、a2，则front指针指向下标为2的位置，rear不变，再入队a5，此时front指针不变，rear指针就移动到数组之外

假设这个队列的总个数不超过5个，但目前如果接着入队的话，因数组末尾元素以及占用，就会产生数组越界的错误，可实际上，我们的队列在下标为0和1的地方还是空闲的。
我们把这种现象叫做“假溢出”

2、循环队列定义

解决假溢出的办法就是后面满了，就再从头开始，也就是头尾相接的循环

我们把队列的头尾相接的顺序存储结构称为循环队列

我们把上面例子的rear改为指向下标为01的位置，这样就不会造成指针指向不明的问题了

接着入队a6，将它放置于下标为0处，rear指针指向下标为1处。若再入队a7，则rear指针就与front指针重合，同时指向下标为2的位置

• 此时问题又出来了，我们刚才说，空队列时，front等于rear，现在当队列满时，也是front等于rear，尼玛如何判断此时的队列究竟是空还是满呢？
• 办法一是设置一个标志变量flag，当front==rear，且flag=0时为队列空，当front==rear，且falg=1时为队列满
• 办法二是当队列空时，条件就是front=rear，当队列满时，我们修改其条件，保留一个元素空间。也就是说，队列满时，数组中还有一个空闲单元。

队列满的条件是（rear+1）%QueueSize==front
（取模%的目的是为了整合rear与front大小为一个问题）

比如上图的左图：
front=0，rear=4，（4+1）%5=0，此时队列满

上图的右图：
front=2，rear=1，（1+1）%5=2，此时队列也是满的

而对于图4-12-6，front=6，而rear=0，（0+1）%5=1，1≠2，此时队列没有满

当rear>front时，此时队列长度为rear-front
当rear<front时，队列长度为两段，一段是Queue Size-front，另一段是0+rear，加在一起，队列长度为rear-front+Queue Size

计算队列长度公式为：

（rear-front+Queue Size）%Queue Size

在这里插入代码片typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */

/* 循环队列的顺序存储结构 */
typedef struct
{
	QElemType data[MAXSIZE];
	int front;    	/* 头指针 */
	int rear;		/* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
}SqQueue;

/* 初始化一个空队列Q */
Status InitQueue(SqQueue *Q)
{
	Q->front=0;
	Q->rear=0;
	return  OK;
}

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

/* 若队列未满，则插入元素e为Q新的队尾元素 */
Status EnQueue(SqQueue *Q,QElemType e)
{
	if ((Q->rear+1)%MAXSIZE == Q->front)	/* 队列满的判断 */
		return ERROR;
	Q->data[Q->rear]=e;			/* 将元素e赋值给队尾 */
	Q->rear=(Q->rear+1)%MAXSIZE;/* rear指针向后移一位置， */
								/* 若到最后则转到数组头部 */
	return  OK;
}

/* 若队列不空，则删除Q中队头元素，用e返回其值 */
Status DeQueue(SqQueue *Q,QElemType *e)
{
	if (Q->front == Q->rear)			/* 队列空的判断 */
		return ERROR;
	*e=Q->data[Q->front];				/* 将队头元素赋值给e */
	Q->front=(Q->front+1)%MAXSIZE;	/* front指针向后移一位置， */
									/* 若到最后则转到数组头部 */
	return  OK;
}

四、队列的链式存储结构及实现

队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列

空队列时，front和rear都指向头结点

typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */

typedef struct QNode	/* 结点结构 */
{
   QElemType data;
   struct QNode *next;
}QNode,*QueuePtr;

typedef struct			/* 队列的链表结构 */
{
   QueuePtr front,rear; /* 队头、队尾指针 */
}LinkQueue;

1、队列的链式存储结构——入队操作

入队操作时，其实就是在链表尾部插入结点

/* 插入元素e为Q的新的队尾元素 */
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;	/* 把拥有元素e的新结点s赋值给原队尾结点的后继，见图中① */
	Q->rear=s;		/* 把当前的s设置为队尾结点，rear指向s，见图中② */
	return OK;
}

2、队列的链式存储结构——出队操作

入队操作时，其实就是头结点的后继结点出队，将头结点的后继改为它后面的结点，若链表除头结点外只剩一个元素时，则需将rear指向头结点，如下图所示：

/*若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR*/
Status DeQueue(LinkQueue *Q, QElemType *e){
    QueuePtr p;
    if(Q->front == Q->rear){
        exit(OVERFLOW);
    }
    p = Q->front->next;/*将欲删除的队头结点暂存给p，见上图中①*/
    *e = p->data;/*将欲删除的队头结点的值赋值给e*/
    Q->front->next = p->next;/*将原队头结点后继p->next赋值给头结点后继，*/
                            /*见上图中②*/
    if(Q->rear == p){/*若队头是队尾，则删除后将rear指向头结点，见上图中③*/
        Q->rear = Q->front;
    }
    free(p);
    return OK;
}

在可以确定队列长度最大值的情况下，建议用循环队列

无法预估队列的长度时，则用链队列

对于栈来说，如果是两个相同数据类型的栈，则可以使用数组的两端作栈底的方法来让两个栈共享数据，可以最大化地利用数组空间。

对于队列来说，为了避免数组插入和删除时需要移动数据，于是引入循环队列，使得队头和队尾可以在数组中循环变化。解决了移动数据的时间损耗，使得原本插入和删除的时间复杂度O(n)变成了O(1)。