栈 & 队列（2）

1.队列的定义

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

队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。假设队列是q = （ a1, a2, ......, an），那么a1就是队头元素，而an是队尾元素。这样我们删除时，总是从a1开始，而插入时，列在最后。排在第一个的优先出列，最后来的当然排在队伍最后。

2.队列的抽象数据类型

同样是线性表，队列也有类似线性表的各种操作，不同的就是插入数据只能在队尾进行，删除数据只能在队头进行。

ADT 队列（Queue）

Data

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

Operation

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

DestroyQueue(* Q)：若队列Q存在，则销毁它。

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

QueueEmpty(* Q)：若队列为空，返回true,否则返回false。

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

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

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

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

endADT

3.循环队列

头尾相接的循环，队列的这种头尾相接的顺序存储结构称为循环队列。

通用的计算队列长度公式为：

（rear - front + QueueSIZE）% QueueSIZE

循环队列的顺序存储结构代码如下：

typedef int QElemType;

typedef struct

{

QElemType data[MAXSIZE];

int front;

int rear;

}SqQueue;

4.循环队列相关代码

循环队列的初始化代码：

Status InitQueue(SqQueue *Q)

{

Q -> front = 0;

Q -> rear = 0;

return OK;

}

循环队列求长度代码：

int QueueLength(SqQueue Q)

{

return ( Q.rear - Q.front + MAXSIZE) % MAXSIZE;

}

循环队列的入队操作代码：

Status EnQueue (SqQueue * Q, QElemType e)

{

if ( ( Q -> rear + 1) % MAXSIZE == Q -> front) //队列满的判断

return ERROR；

Q -> data[Q -> rear] = e;

Q -> rear = (Q -> rear +1) %MAXSIZE;  //rear指针向后移一位

return OK;

}

循环队列出队操作代码：

Status DeQueue( SqQueue *Q, QElemType *e)

{

if( Q -> front == Q -> rear) //队列空的判断

return ERROR; 

*e = Q -> data[Q -> front];

Q -> front = (Q -> front + 1) % MAXSIZE;

return OK;

}

5.队列的链式存储结构

链队列的结构：

typedef int QElemType;

typedef struct QNode // 结点结构

{

QElemType data;

struct QNode *next;

}QNode, *QueuePtr;

typedef struct //队列的链表结构

{

QueuePtr front, rear;  //队头、队尾指针

}LinkQueue;

6.队列的链式存储结构 ---- 入队操作

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

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; //把s 中的e赋值给原队尾结点的后继

Q -> rear = s;  // 当前的s设置为队尾结点，rear指向s

return OK;

}

7.队列的链式存储结构 ---- 出队操作

出队操作时，就是头结点的后继结点出队，将头结点的后继改成它后面的结点，若链表除头结点外只剩一个元素时，则需将rear指向头结点，代码：、

Status DeQueue(LinkQueue *Q, QElemType *e)

{

QueuePtr p;

if(Q -> front == Q -> rear)

return ERROR;

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;

}

8.顺序队列

建立顺序队列结构必须为其静态分配或动态申请一片连续的存储空间，并设置两个指针进行管理。一个是队头指针front，它指向队头元素；另一个是队尾指针rear，它指向下一个入队元素的存储位置。

每次在队尾插入一个元素是，rear增1；每次在队头删除一个元素时，front增1。随着插入和删除操作的进行，队列元素的个数不断变化，队列所占的存储空间也在为队列结构所分配的连续空间中移动。

当front=rear时，队列中没有任何元素，称为空队列。当rear增加到指向分配的连续空间之外时，队列无法再插入新元素，但这时往往还有大量可用空间未被占用，这些空间是已经出队的队列元素曾经占用过得存储单元。

顺序队列中的溢出现象：

1."下溢"现象：当队列为空时，做出队运算产生的溢出现象。“下溢”是正常现象，常用作程序控制转移的条件。

2."真上溢"现象：当队列满时，做进栈运算产生空间溢出的现象。“真上溢”是一种出错状态，应设法避免。

3."假上溢"现象：由于入队和出队操作中，头尾指针只增加不减小，致使被删元素的空间永远无法重新利用。当队列中实际的元素个数远远小于向量空间的规模时，也可能由于尾指针已超越向量空间的上界而不能做入队操作。该现象称为"假上溢"现象。

9.循环队列

在实际使用队列时，为了使队列空间能重复使用，往往对队列的使用方法稍加改进：无论插入或删除，一旦rear指针增1或front指针增1 时超出了所分配的队列空间，就让它指向这片连续空间的起始位置。

自己真从MaxSize-1增1变到0，可用取余运算rear%MaxSize和front%MaxSize来实现。这实际上是把队列空间想象成一个环形空间，环形空间中的存储单元循环使用，用这种方法管理的队列也就称为循环队列。

除了一些简单应用之外，真正实用的队列是循环队列。

在循环队列中，当队列为空时，有front=rear，而当所有队列空间全占满时，也有front=rear。

为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件时front=rear，而队列判满的条件时front=（rear+1）%MaxSize。

10.栈与队列

栈（stack）是限定仅在表尾进行插入和删除操作的线性表

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

它们均可用线性表的顺序结构存储结构来实现，但都存在着顺序存储的一些弊端，

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

对于队列来说，为了避免数组插入和删除时需要移动数据，于是就引入了循环队列，使得队头和队尾可以在数组中循环变化。解决了移动数据的时间损耗。

栈：

. 顺序栈

. 两栈共享空间

. 链栈

队列：

. 顺序队列

. 循环队列

. 链队列