《大话数据结构》笔记——第4章 栈与队列

4.1 开场白

略

4.2 栈的定义

4.2.1 栈的定义

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

我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为后进先出（Last In First Out）的线性表，简称 LIFO 结构。

理解栈的定义需要注意：

首先它是一个线性表，也就是说，栈元素具有线性关系，即前驱后继关系。只不过它是一种特殊的线性表而已。定义中说是在线性表的表尾进行插入和删除操作，这里表尾是指栈顶，而不是栈底。

它的特殊之处就在于限制了这个线性表的插入和删除位置，它始终只在栈顶进行。这也就使得：栈底是固定的，最先进栈的只能在栈底。

栈的插入操作，叫作进栈，也叫压栈、入栈。类似子弹入弹夹，如图所示。

栈的删除操作，叫作出栈，也有的叫作弹栈。如同弹夹中的子弹出夹，如图所示。

4.2.2 进栈出栈变化形式

现在我要问问大家，这个最先进栈的元素，是不是就只能是最后出栈呢？

答案是不一定，要看什么情况。栈对线性表的插入和删除的位置进行了限制，并没有对元素进出的时间进行限制，也就是说，在不是所有元素都进栈的情况下，事先进去的元素也可以出栈，只要保证是栈顶元素出栈就可以了。

举例来说，如果我们现在是有3个整型数字元素1、2、3依次出栈，会有哪些出栈次序呢？

• 第一种：1、2、3进，再3、2、1出。这是最简单的最好理解的一种，出栈次序为321。
• 第二种：1进，1出，2进，2出，3进，3出。也就是进一个就出一个，出栈次序为123。
• 第三种：1进，2进，2出，1出，3进，3出。出栈次序为213。
• 第四种：1进，1出，2进，3进，3出，2出。出栈次序为132。
• 第五种：1进，2进，2出，3进，3出，1出。出栈次序为231。

有没有可能是312这种次序出栈呢？答案是肯定不会。因为3先出栈，就意味着，3曾经进栈，既然3都进栈了，那也就意味着，1和2已经进栈了，此时，2一定是在1的上面，就是更接近栈顶，那么出栈只可能是321，不然不满足123一次进栈的要求，所以此时不会发生1比2先出栈的情况。

从这个简单的例子就能看出，只是3个元素，就有5种可能的出栈次序，如果元素数量多，其实出栈的变化将会更多的。这个知识点一定要弄明白。

4.3 栈的抽象数据类型

对于栈来讲，理论上线性表的操作特性它都具备，可由于它的特殊性，所以针对它在操作上会有些变化。特别是插入和删除操作，我们改名为 push 和 pop，英文直译的话是压和弹，更容易理解。你就把它当成是弹夹的子弹压入和弹出就好记忆了，我们一般叫进栈和出栈。

ADT 栈(stack)
Data
	同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。
Operation
	InitStack ( *S )：初始化操作.建立一个空栈S。
	DestroyStack ( *S )：若栈存在，則销毁它。
	ClearStack (*S)：将栈清空。
	StackEmpty ( S ):若栈为空，返回true,否則返回 false。
	GetTop (S,*e)：若栈存在且非空，用e返回S的栈顶元素。
	Push (*S,e)：若栈S存在，插入新元素e到栈S中并成为栈頂元素。
	Pop (*S,*e)：删除栈S中栈顶元素，并用e返回其值。
	StackLength (S)：返回回栈S的元素个数。
endADT

由于栈本身就是一个线性表，那么上一章我们讨论了线性表的顺序存储和链式存储，对于栈来说，也是同样适用的。

4.4 栈的顺序存储结构及实现

4.4.1 栈的顺序存储结构

既然栈是线性表的特例，那么栈的顺序存储其实也是线性表顺序存储的简化，我们简称为顺序栈。线性表是用数组来实现的，想想看，对于栈这种只能一头插入删除的线性表来说，用数组哪一端来作为栈顶和栈底比较好？

对，没错，下标为 0 的一端作为栈底比较好，因为首元素都存在栈底，变化最小，所以让它作栈底。

我们定义一个 top 变量来指示栈顶元素在数组中的位置，这 top 就如同中学物理学过的游标卡尺的游标，它可以来回移动，意味着栈顶的 top 可以变大变小，但无论如何游标不能超出尺的长度。同理，若存储栈的长度为 StackSize，则栈顶位置 top 必须小于 StackSize。当栈存在一个元素时，top 等于 0，因此通常把空栈的判定条件定为 top 等于 -1。

来看栈的结构定义：

typedef int SElemType;	//SElemtype 类型根据实际情况而定，这里假设为 int
typedef struct
{
	SElemType data[MAXSIZE];
	int top;		//用于栈顶指针
}SqStack;

若现在有一个栈，StackSize 是 5，则栈普通情况、空栈和栈满的情况示意图如图所示。

4.4.2 栈的顺序存储结构——进栈操作

对于栈的插入，即进栈操作，其实就是做了如图所示的处理。

因此对于进栈操作 push，其代码如下：

/*插入元素 e 为新的栈顶元素*/
Status Push(SqStack *S, SElemType e)    
{
	if (S->top == MAXSIZE - 1) //栈满
	{
		return ERROR;
	}
	S->top++;				//栈顶指针增加一
	S->data[S->top] = e;	//将新插入的元素赋值给栈顶空间
	return OK;
}

4.4.3 栈的顺序存储结构——出栈操作

出栈操作pop，代码如下：

/*若栈不空，则删除 S 的栈顶元素，用 e 返回其值，并返回 OK，否则返回 ERROR*/
Status Pop(SqStack *S, SElemType *e)
{
	if (S->top == -1)
	{
		return ERROR;
	}
	*e = S->data[S->top]; //将要删除的栈顶元素赋值给 e
	S->top--; //栈顶指针减一
	return OK;
}

两者没有涉及到任何循环语句，因此时间复杂度均是 O(1)。

4.5 两栈共享空间

其实栈的顺序存储还是很方便的，因为它只准栈顶进出元素，所以不存在线性表插入和删除时需要移动元素的问题。不过它有一个很大的缺陷，就是必须事先确定数组存储空间大小，万一不够用了，就需要编程手段来扩展数组的容量，非常麻烦。对于一个栈，我们也只能尽量考虑周全，设计出合适大小的数组来处理，但对于两个相同类型的栈，我们却可以做到最大限度地利用其事先开辟的存储空间来进行操作。

如果我们有两个相同类型的栈，我们为它们各自开辟了数组空间，极有可能是第一个栈已经满了，再进栈就溢出了，而另一个栈还有很多存储空间空闲。这又何必呢？我们完全可以用一个数组来存储两个栈，只不过需要点小技巧。

我们的做法如下图所示，数组有两个端点，两个栈又两个栈底，让一个栈的栈底为数组的始端，即下标为 0 处，另一个栈为栈的末端，即下标为数组长度 n-1 处。这样，两个栈如果增加元素，就是两端点向中间延伸。

其实关键思路是：它们是在数组的两端，向中间靠拢。top1 和 top2 是栈 1 和栈 2 的栈顶指针，可以想象，只要它们俩不见面，两个栈就可以一直使用。

从这里也就可以分析出来，栈 1 为空时，就是 top1 等于 -1 时；而当 top2 等于 n 时，即是栈 2 为空时，那什么时候栈满呢？

想想极端的情况，若栈 2 是空栈，栈 1 的 top1 等于 n-1 时，就是栈 1 满了。反之，当栈 1 为空栈时，top2 等于 0 时，为栈 2 满。但更多的情况就是两个栈见面之时，也就是两个指针之间相差 1 时，即 top1 + 1 == top2 为栈满。

两栈共享空间的结构的代码如下所示：

/* 两栈共享空间结构 */
typedef struct
{
	SElemType data[MAXSIZE];
	int top1; //栈 1 栈顶指针
	int top2; //栈 2 栈顶指针
}SqDoubleStack; 

对于两栈共享空间的 push 方法，我们除了要插入元素值参数外，还需要有一个判断是栈 1 还是栈 2 的栈号参 stackNumber。插入元素的代码如下：

/* 插入元素 e 为新的栈顶元素 */
Status Push(SqDoubleStack *S, int e, int StackNumber)
{
	if (S->top1 + 1 == S->top2) //栈已满，不能再 push 新元素了
	{
		return ERROR;
	}
	if (StackNumber == 1)//栈 1 有元素进栈
	{
		S->data[++S->top1] = e; //若栈 1 则先 top1+1 后给数组元素赋值
	}
	if (StackNumber == 2) //栈 2 有元素进栈
	{
		S->data[--S->top2] = e; //若栈 2 则先 top2-1 后给数组元素赋值
	}
	return OK;
}

对于两栈共享空间的 pop 方法，参数就只是判断栈 1 栈 2 的参数 stackNumber，代码如下：

/* 若栈不空，则删除 S 的栈顶元素，用 e 返回其值，并返回 OK，否则返回 ERROR */ 
Status Pop(SqDoubleStack *S, SElemType *e, int StackNumber)
{
	if (StackNumber == 1)
	{
		if (S->top1 == -1)
		{
			return ERROR; //说明栈 1 已经是空栈，溢出
		}
		*e = S->data[S->top1--]; //将栈 1 的栈顶元素出栈
	}
	else if (StackNumber == 2)
	{
		if (S->top2 == MAXSIZE)
		{
			return ERROR; //说明栈 2 已经是空栈，溢出
		}
		*e = S->data[S->top2++]; //将栈 2 的栈顶元素出栈
	}
	return OK;
}

事实上，使用这样的数据结构，通常都是当两个栈的空间需求有相反关系时，也就是一个栈增长时另一个栈在缩短的情况。

4.6 栈的链式存储结构及实现

4.6.1 栈的链式存储结构

讲完了栈的顺序存储结构，我们现在来看看栈的链式存储结构，简称为链栈。

想想看，栈只是栈顶来做插入和删除操作，栈顶放在链表的头部还是尾部呢？由于单链表有头指针，而栈顶指针也是必须的，那干嘛不让它俩合二为一呢，所以比较好的办法是把栈顶放在单链表的头部。另外，都已经有了栈顶在头部了，单链表中比较常用的头结点也就失去了意义，通常对于链栈来说，是不需要头结点的。

对于链栈来说，基本不存在栈满的情况，除非内存已经没有可以使用的空间，如果真的发生，那此时的计算机操作系统已经面临死机奔溃的情况，而不是这个链栈是否溢出的问题。

但对于空栈来说，链表原定义是头指针指向空，那么链栈的空其实就是 top=NULL 的时候。

链栈的结构代码如下：

typedef struct StackNode
{
	SElemType data;
	struct StackNode *next;
}StackNode,*LinkStackPtr;
 
typedef struct LinkStack
{
	LinkStackPtr top;
	int count;
}LinkStack;

4.6.2 栈的链式存储结构——进栈操作

对于链栈的进栈 push 操作，假设元素值为 e 的新结点是 s，top 为栈顶指针，示意图如图所示，代码如下。

/* 插入元素 e 为新的栈顶元素 */
Status Push(LinkStack *S, SElemType e)
{
	LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));
	s->data = e;
	s->next = S->top; //把当前的栈顶元素赋值给新结点的直接后继，如图中操作 1
	S->top = s; //将新结点s赋值给栈顶指针，如图中操作 2
	S->count++; 
	return OK;
}

4.6.3 栈的链式存储结构——出栈操作

至于链栈的出栈 pop 操作，也是很简单的三句操作。假设变量 p 用来存储要删除的栈顶结点，将栈顶指针下移一位，最后释放 p 即可，如图所示。

/* 若栈不空，则删除 S 的栈顶元素，用 e 返回其值，并返回 OK；否则返回 ERROR */
Status Pop(LinkStack *S, SElemType *e)
{
	LinkStackPtr p;
	if (StackEmpty(S)) //判断栈是否为空
	{
		return ERROR;
	}
	*e = S->top->data;
	p = S->top; //将栈顶结点赋值给 p，如图中操作 3
	S->top = S->top->next; //使得栈顶指针下移一位，指向后一结点，如图中操作 4
	free(p); //释放结点 p
	S->count--;
	return OK;
}

链栈的进栈的push和出栈pop操作都很简单，没有任何循环操作，时间复杂度均为O(1)。

对比一下顺序栈与链栈，它们在时间复杂度上是一样的，均为O(1)。对于空间性能，顺序栈需要事先确定一个固定的长度，可能会存在内存空间浪费的问题，但它的优势是存取时定位很方便，而链栈则要求每个元素都有指针域，这同时也增加了一些内存开销，但对于栈的长度无限制。所以他们的区别和线性表中讨论的一样，如果栈的使用过程中元素变化不可预料，有时候很小，有时候非常大，那么最好是用链栈，反之，如果它的变化在可控范围内，建议使用顺序栈会更好一些。

4.7 栈的作用

有的同学可能会觉得，用数组或链表直接实现功能不就行了吗？干嘛要引入栈这样的数据结构呢？这个问题问得好。

其实这和我们明明有两只脚可以走路，干嘛还要乘汽车、火车、飞机一样。理论上，陆地上的任何地方，你都是可以靠双脚走到的，可那需要多少时间和精力呢？我们更关注的是到达而不是如何去的过程。

栈的引入简化了程序设计的问题，划分了不同关注层次，使得思考范围缩小，更加聚焦于我们要解决的问题核心。反之，像数组等，因为要分散精力去考虑数组的下标增减等细节问题，反而掩盖了问题的本质。

所以现在的许多高级语言，比如 Java、C# 等都有对栈结构的封装，你可以不用关注它的实现细节，就可以直接使用 Stack 的 push 和 pop 方法，非常方便。

4.8 栈的应用——递归

栈有一个很重要的应用：在程序设计语言中实现了递归。那么什么是递归呢？

我们先来看一个经典的递归例子：斐波那契数列（Fibonacci）。

4.8.1 斐波那契数列的实现

如果兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对小兔子来。假设所有兔都不死，那么一年以后可以繁殖多少对兔子呢？

我们拿新出生的一对小兔子分析一下：第一个月小兔子没有繁殖能力，所以还是一对；两个月后，生下一对小兔子数共有两对；三个月以后，老兔子又生下一对，因为小兔子还没有繁殖能力，所以一共是三对。依次类推可以列出下表。

所经过的月数	1	2	3	4	5	6	7	8	9	10	11	12
兔子的对数	1	1	2	3	5	8	13	21	34	55	89	144

这个数列有个十分明显的特点，那就是：前面相邻两项之和，构成了后一项。

如果我们用数学函数来定义就是：

先考虑一下，如果我们要实现这样的数列用常规的迭代的办法如何实现？假设我们需要打印出前40位的斐波那契数列数。代码如下：

int main() {
	int i;
	int a[40];
	a[0] = 0;
	a[1] = 1;
	for(i=2; i<40; i++) {
		a[i] = a[i-1] + a[i-2]; 
		printf("%d\n",a[i]);
	} 
	return 0;
}

但其实我们的代码，如果用递归来实现，还可以更简单

int Fbi(int i) {
	if(i<2) {
		return i == 0 ? 0 : 1;
	}
	return Fbi(i-1) + Fbi(i-2); /*这里 Fbi 就是函数自己，它在调用自己*/
}

int main() {
	int i;
	for(i=2; i<40; i++) {
		printf("%d\n",Fbi(i));
	} 
	return 0;
}

怎么样，相比较迭代的代码，是不是干净很多。

4.8.2 递归定义

在高级语言中，调用自己和其他函数并没有本质的不同。我们把一个直接调用自己或通过一系列的调用语句间接地调用自己的函数，称做递归函数。

当然，写递归程序最怕的就是陷入永不结束的无穷递归中，所以，每个递归定义必须至少有一个条件，满足时递归不再进行，即不再引用自身而是返回值退出。比如刚才的例子，总有一次递归会使得 i 小于 2 的，这样就可以执行 return i 的语句而不用继续递归了。

对比了两种实现斐波那契的代码。迭代何递归的区别是：迭代使用的是循环结构，递归使用的是选择结构。递归能使程序的结构更清晰、更简洁、更容易让人理解，从而减少读懂代码的时间。但是大量的递归调用会建立函数的副本，会耗费大量的时间和内存。迭代则不需要反复调用函数和占用额外的内存。因此我们应该视不同情况选择不同的代码实现方式。

那么我们讲了这么多递归的内容，和栈有什么关系呢？这得从计算机系统的内部说起。

前面我们已经看到递归是如何执行它的前行和退回阶段的。递归过程退回的顺序是它前行顺序的逆序。在退回过程中，可能要执行某些动作，包括恢复在前行过程中存储起来的某些数据。

这种存储某些数据，并在后面又以存储的逆序恢复这些数据，以提供之后使用的需求，显然很符合栈这样的数据结构，因此，编译器使用栈实现递归就没什么好惊讶的了。

4.9 栈的应用——四则表达式求值

4.9.1 后缀表示法定义

栈的现实应用也很多，我们再来重点讲一个比较常见的应用：数学表达式的求值。

"9+(3-1)*3+10/2"，这是一个非常简单的题目，心算也可以很快算出是 20。可就这么简单的题目，老式计算器却不能在一次输入后马上得出结果，很是不方便。

这里面的困难就在于乘除在加减的后面，却要先运算，而加入了括号后，就变得更加复杂。

但仔细观察后发现，括号都是成对出现的，有左括号就一定会有右括号，对于多重括号，最终也是完全嵌套匹配的。这用栈结构正好合适，只要碰到左括号，就将次左括号进栈，不管表达式有多少重括号，反正遇到左括号就进栈，而后面出现右括号时，就让栈顶的左括号出栈，期间让数字运算。这样，最终有括号的表达式从左到右巡查一遍，栈应该是由空到有元素，最终再因全部匹配成功后成为空栈的结果。

但对于四则运算，括号也只是当中的一部分，先乘除后加减使得问题依然复杂，如何有效地处理它们呢？我们伟大的科学家想到了好办法。

20世纪50年代，波兰逻辑学家Jan Lukasiewicz，想到了一种不需要括号的后缀表达法，我们也把它称为逆波兰（Reverse Polish Notation，RPN）表示。这种后缀表示法，是表达式的一种新的显示方式，非常巧妙地解决了程序实现四则运算的难题。

我们先来看看，对于 "9+(3-1)*3+10/2"，如果要用后缀表示法应该是什么样子："9 3 1- 3*+ 10 2/+"，这样的表达式称为后缀表达式，叫后缀的原因在于所有的符号都是在要运算数字的后面出现。

4.9.2 后缀表达式计算结果

为了解释后缀表达式的好处，我们先来看看，计算机如何应用后缀表达式计算出最终的结果 20 的。

后缀表达式："9 3 1- 3*+ 10 2/+"

规则：从左到右遍历表达式的每个数字和符号，遇到是数字就进栈，遇到是符号，就将处于栈顶两个数字出栈，进行运算，运算结果进栈，一直到最终获得结果。

1. 初始化一个空栈。此栈用来对要运算的数字进出使用。如图 4-9-1 的左图所示。

2. 后缀表达式中前三个都是数字，所以 9、3、1 进栈，如图 4-9-1 的右图所示。

   

3. 接下来是"-"，所以将栈中的 1 出栈作为减数，3 出栈作为被减数，并运算 3-1 得到 2，再将 2 进栈，如图 4-9-2 的左图所示。

4. 接着是数字3进栈，如图 4-9-2 的右图所示。

   

5. 后面是"*"，也就意味着栈中 3 和 2 出栈，2 与 3相乘，得到 6，并将 6 进栈，如图 4-9-3 的左图所示。

6. 下面是"+"，所以栈中 6 和 9 出栈，9 与 6 相加，得到 15，将 15 进栈，如图 4-9-3 的右图所示。

   

7. 接着是 10 与 2 两数字进栈，如图 4-9-4 的左图所示。

8. 接下来是符号"/"，因此，栈顶的 2 与 10 出栈，10 与 2 相除，得到 5，将 5 进栈，如图 4-9-4 的右图所示。

   

9. 最后一个是符号 “+”，所以 15 与 5 出栈并相加，得到 20，将 20 出栈，如图 4-9-5 的左图所示。

10. 结果是 20 出栈，栈变为空，如图 4-9-5 的右图所示。

    
    果然，后缀表达法可以很顺利解决计算的问题。但这个后缀表达式 "9 3 1- 3*+ 10 2/+"是怎么出来的？所以下面，我们就来推导如何让 "9+(3-1)*3+10/2"转化为 "9 3 1- 3*+ 10 2/+"

4.9.3 中缀表达式转后缀表达式

我们把平时所用的标准四则运算表达式，即 "9+(3-1)*3+10/2" 叫做中缀表达式。因为所有的运算符号都在两数字的中间，现在我们的问题就是中缀到后缀的转化。

中缀表达式 "9+(3-1)*3+10/2" 转化为后缀表达式 "9 3 1- 3*+ 10 2/+"

规则：从左到右遍历中缀表达式的每个数字和符号，若是数字就输出，即成为后缀表达式的一部分；若是符号，则判断其与栈顶符号的优先级，是右括号或优先级低于栈顶符号（乘除优先加减）则栈顶元素依次出栈并输出，并将当前符号进栈，一直到最终输出后缀表达式为止。

1. 初始化一空栈，用来对符号进出栈使用。如图 4-9-6 的左图所示。

2. 第一个字符是数字 9，输出 9，后面是符号 “+”，进栈。如图 4-9-6 的右图所示。

   

3. 第三个字符是 “(”，依然是符号，因其只是左括号，还未配对，故进栈。如图 4-9-7 的左图所示。

4. 第四个字符是数字 3，输出，总表达式为 9 3，接着是 “-”，进栈。如图 4-9-7 的右图所示。

   

5. 接下来是数字 1，输出，总表达式为 9 3 1，后面是符号 “)”，此时，我们需要去匹配此前的 “(”，所以栈顶依次出栈，并输出，直到 “(” 出栈为止。此时左括号上方只有 “-”，因此输出 “-”。总的输出表达式为 9 3 1 -。如图 4-9-8 的左图所示。

6. 接着是数字 3，输出，总的表达式为 9 3 1 - 3。紧接着是符号 “X”，因为此时的栈顶符号为 “+” 号，优先级低于 “X”，因此不输出，"*" 进栈。如图 4-9-8 的右图所示。

   

7. 之后是符号 “+”，此时当前栈顶元素 “*” 比这个 “+” 的优先级高，因此栈中元素出栈并输出（没有比 “+” 号更低的优先级，所以全部出栈），总输出表达式为 9 3 1-3 * +。然后将当前这个符号 “+” 进栈。

8. 紧接着数字 10，输出，总表达式变为 9 3 1-3 * + 10。后是符号 “/”，所以 “/” 进栈。如图 4-9-9 的右图所示。

   

9. 最后一个数字 2，输出，总的表达式为 9 3 1 - 3 * + 10 2。如图 4-9-10 的左图所示。

10. 因已经到最后，所以将栈中符号全部出栈并输出。最终输出的后缀表达式结果为 9 3 1 - 3 * + 10 2 /+。如图 4-9-10 的右图所示。

    

从刚才的推导中你会发现，要想让计算机具有处理我们通常的标准（中缀）表达式的能力，最重要的就是两步：

1. 将中缀表达式转化为后缀表达式（栈用来进出运算的符号）。
2. 将后缀表达式进行运算得出结果（栈用来进出运算的数字）。

4.10 队列的定义

队列是一种先进先出（First In First Out）的线性表，简称 FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。假设队列是 q=(a1,a2,…,an)，那么 a1 就是队头元素，而 an 是队尾元素。这样我们就可以删除时，总是从 a1 开始，而插入时，列在最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后，如图 4-10-1 所示。

4.11 队列的抽象数据类型

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

ADT 队列(Queue)
Data
	同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。
Operation
	InitQueue(*Q)：初始化操作，建立一个空队列Q。
	DestroyAQueue(*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  

4.12 循环队列

线性表有顺序存储和链式存储，队列作为一种特殊的线性表，也同样存在这两种存储方式。我们先来看队列的顺序存储结构。

4.12.1 队列顺序存储的不足

我们假设一个队列有 n 个元素，则顺序存储的队列需建立一个大于 n 的数组，并把队列的所有元素存储在数组的前 n 个单元，数组下标为 0 的一端即是队头。所谓的入队列操作，其实就是在队尾追加一个元素，不需要移动任何元素，因此时间复杂度为O (1)，如图 4-12-1 所示。

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

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

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

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

出队 a1、a2，则 front 指针指向下标为 2 的位置，rear 不变，如图 4-12-5 的左图所示，再入队 a5，此时 front 指针不变，rear 指针移动到数组之外。如图 4-12-5 的右图所示。

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

4.12.2 循环队列定义

所以解决假溢出的办法就是后面满了，就再从头开始，也就是头尾相接的循环。我们把队列的这种头尾相接的顺序存储结构称为循环队列。

刚才的例子继续，图 4-12-5 的 rear 可以改为指向下标为 0 的位置，这样就不会造成指针指向不明的问题了，如图 4-12-6 所示。

接着入队 a6，将它放置于下标为 0 处，rear 指针指向下标为 1 处，如图 4-12-7 的左图所示。若再入队 a7，则 rear 指针就与 front 指针重合，同时指向下标为 2 的位置，如图 4-12-7 的右图所示。

• 此时问题又出来了，我们刚才说，空队列时，front 等于 rear，现在当队列满时，也是 front 等于 rear，那么如何判断此时的队列究竟是空还是满呢？
• 办法一是设置一个标志变量 flag，当 front == rear，且 flag=0 时为队列空，当 front == rear，且 flag=1 时为队列满。
• 办法二是当队列空时，条件就是 front = rear，当队列满时，数组中还有一个空闲单元。例如图 4-12-8 所示，我们就认为此队列已经满了，也就是说，我们不允许图 4-12-7 的右图情况出现。

我们重点来讨论第二种方法，由于 rear 可能比 front 大，也可能比 front 小，所以尽管它们只相差一个位置时就是满的情况，但也可能是相差整整一圈。若队列的最大尺寸为 QueueSize，则：

• 队列满的条件是：（rear+1）%QueueSize==front。

• 通用的计算队列长度公式为：（rear-front+QueueSize）%QueueSize

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

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

循环队列的初始化代码如下：

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

循环队列求队列长度代码如下：

/* 返回 Q 的元素个数，也就是队列的当前长度 */
int QueueLenght(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;
}

但循环队列又面临着数组可能会溢出的问题，所以我们还需要研究一下不需要担心队列长度的链式存储结构。

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

队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列。为了操作上的方便，我们将队头指针指向链队列的头结点，而队尾指针指向终端结点，如图 4-13-1 所示。

空队列时，front 和 rear 都指向头结点，如图 4-13-2 所示。

链队列的结构为：

/* 结点结构 */
typedef struct QNode 
{
	QElemType data; //数据域
	struct QNode *next; //指针域
}QNode,*QueuePtr;
 
/* 队列的链表结构 */
typedef struct 
{
	QueuePtr front, rear; //队头、队尾指针
}LinkQueue;

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

入队操作时，其实就是在链表尾部插入结点，如图 4-13-3 所示。

其代码如下：

/* 插入元素e为Q的新的队尾元素 */
Status EnQueue(LinkQueue *Q, QElemType e)
{
	QueuePtr s = (QueuePtr)malloc(sizeof(QNode)); //为新结点申请内存空间
	if (s == NULL) //内存分配失败
	{
		exit(OVERFLOW); //接退出进程，返回错误代码 OVERFLOW 给操作系统
	}
	s->data = e;
	s->next = NULL;
	Q->rear->next = s; //把拥有元素 e 的结点 s 赋值给原队尾结点的后继，如上图操作 1 所示
	Q->rear = s; //把当前的 s 设置为队尾结点，rear 指向 s，如上图操作 2 
	return OK;
}

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

出队操作时，就是头结点的后继结点出队，将头结点的后继改为它后面的节点，若链表除头结点外只剩一个元素时，则需将 rear 指向头结点，如图 4-13-4 所示。

代码如下：

/* 若队列不为空，删除 Q 的队头元素。用 e 返回其值，并返回 OK,否则返回 ERROR */ 
Status DeQueue(LinkQueue *Q, QElemType *e)
{
	QueuePtr p;
	if (Q->front == Q->rear) //判断是否为空队列
	{
		return ERROR;
	}
	p = Q->front->next; //将欲删除的队头结点暂存给p，如上图操作 1
	*e = p->data; //将欲删除的队头结点的值赋值给e
	Q->front->next = p->next; //将原队头结点后继p->next赋值给头结点后继，如上图操作 2 
	if (Q->rear == p) //若队头是队尾，则删除后将rear指向头结点，如上图操作 3
	{
		Q->rear = Q->front;
	}
	free(p); //释放结点p所指向的内存空间
	return OK;
}

对于循环队列与链队列的比较，可以从两方面来考虑，从时间上，其实它们的基本操作都是常数时间，即都为O(1)的，不过循环队列是事先申请好空间，使用期间不释放，而对于链队列，每次申请和释放结点也会存在一些时间开销，如果入队出队频繁，则两者还是有细微差异。对于空间上来说，循环队列必须有一个固定的长度，所以就有了存储元素个数和空间浪费的问题。而链队列不存在这个问题，尽管它需要一个指针域，会产生一些空间上的开销，但也可以接受。所以在空间上，链队列更加灵活。

总的来说，在可以确定队列长度最大值的情况下，建议用循环队列，如果你无法预估队列的长度时，则用链队列。

4.14 总结回顾

又到了总结回顾的时间。我们这一章讲的是栈和队列，它们都是特殊的线性表，只不过对插入和删除操作做了限制。

• 栈（stack）是限定仅在表尾进行插入和删除操作的线性表。
• 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

它们均可以用线性表的顺序存储结构来实现，但都存在着顺序存储的一些弊端。因此它们各自有各自的技巧来解决这个问题。

1. 对于栈来说，如果是两个相同数据类型的栈，则可以用数组的两端作栈底的方法来让两个栈共享数据，这就可以最大化地利用数组的空间。
2. 对于队列来说，为了避免数组插入和删除时需要移动数据，于是就引入了循环队列，使得队头和队尾可以在数组中循环变化。解决了移动数据的时间损耗，使得本来插入和删除是 O(n) 的时间复杂度变成了 O(1)。

它们也都可以通过链式存储结构来实现，实现原则上与线性表基本相同，如图 4-14-1 所示。

4.15 结尾语

略