数据结构——栈与队列-基本知识点(第四章）

第四章 栈与队列

目录

第四章 栈与队列

4.2 栈的定义

4.2.1 栈的定义

4.2.2进栈出栈变化形式

4.3 栈的抽象数据类型

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

4.4.1 栈的顺序存储结构

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

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

4.5 两栈共享空间

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

4.6.1 栈的链式存储结构

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

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

4.7 栈的作用

4.8 栈的应用——递归

4.8.1 斐波那契数列的实现

4.8.2 递归定义

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

4.9.1 后缀（逆波兰）表示法定义

4.9.2 后缀表达式计算结果

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

4.10 队列的定义

4.11 队列的抽象数据类型

4.12 循环队列

4.12.1 队列顺序存储的不足

4.12.2 循环队列定义

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

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

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

4.14 总结回顾

---

4.2 栈的定义

4.2.1 栈的定义

       一个很简单的例子帮助我们理解栈的使用原理,弹夹式手枪，它的子弹装入弹夹之后，在手枪将子弹打出去时，后装进去的的子弹，先被打出去，装的第一颗子弹往往最后被打出去，这就和数据结构中栈的原理一样，先进后出，后进先出。

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

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

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

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

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

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

4.2.2进栈出栈变化形式

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

       例如现在有1、2、3三个元素依次进栈，出栈次序有321，123，132，213，231。这几种出栈次序，而312这种出栈次序是肯定不会有的，因为进栈次序是规定了的。

4.3 栈的抽象数据类型

       对于栈来讲，理论上线性表的操作特性它都具备，由于它的特殊性，针对它在操作上会有变化，特别是插入和删除操作，取名为push和pop，英文直译压和弹。可以把它当作子弹压入和弹出，一般叫作进栈和出栈。

       栈本身就是一个线性表，所以线性表的顺序存储和链式存储对于栈也是适用的。

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

4.4.1 栈的顺序存储结构

       栈是顺序表的特例，栈的顺序存储是线性表顺序存储的简化，简称顺序栈。线性表是用数组实现的，对于栈把数组下标为0的一端作为栈底，因为首元素都存在栈底，变化最小。

       定义一个top变量来指示栈顶元素在数组中的位置，top就如同中学物理学过的游标卡尺，可以来回移动，意味着栈顶的top可以变大变小，但无论如何游标不能超出尺的长度。

同理，若存储栈的长度为StackSize，则栈顶位置top必须小于StackSize。当栈存在一个元素时，top等于0，因此通常把空栈的判定条件定为top等于-1。

       栈的结构定义：

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

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

       栈的插入，即进栈操作，操作如图所示：

       则进栈操作push，其代码如下所示：

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

       出栈操作pop，代码如下所示：

       进栈操作和出栈操作未涉及到任何循环语句，因此时间复杂度均为O（1）。

4.5 两栈共享空间

       栈的顺序存储还是很方便的，因为它只准栈顶进出元素，所以不存在线性表插入和删除时需要移动元素的问题。但是栈的顺序存储有一个很大的缺陷，就是必须事先确定数组存储空间大小，万一不够用了，就需要编程手段来扩展数组容量，非常麻烦。

       因此对于一个栈，使用时我们要尽量考虑周全，设计出适合大小的数组来处理。对于两个同类型的栈，我们可以做最大限度的利用其事先开辟的空间来进行操作。

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

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

       也可以分析出来，栈1为空时，top1等于-1；栈2为空时，top2等于n。

       对于栈满有两种情况，极端情况：栈1的top1等于n-1时，就是栈1满了。反之，当栈1为空栈时，top2等于0时，为栈2满。正常情况也就是大多数情况下：两个栈见面之时，也就是两个指针之间相差1时，即top1+1==top2为栈满。

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

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

       由于开始已经判断是否有栈满的情况，所以后面的top1+1或top2-1是不用担心溢出问题的。

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

       事实上，使用这样的数据结构，通常都是两个栈的空间需求有相反关系时，也就是一个栈增长时另一个栈在缩短的情况。就像买卖股票一样，你买入时，一定是有一个你不知道的人在做卖出操作。有人赚钱，就一定有人赔钱。这样使用两栈共享空间存储方法才有比较大的意义。否则两个栈都在不停的增长，那很快 就会因栈满而溢出了。

       这只是针对两个具有相同数据类型的栈的一个设计上的技巧，如果是不相同的数据类型的栈，这种办法不但不能更好的处理问题，反而会使问题变得更加复杂。

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

4.6.1 栈的链式存储结构

       栈的链式存储结构，简称链栈。

       由于栈只在栈顶进行插入和删除操作，所以栈顶指针是必须的，而单链表也有头指针，比较好的办法就是将栈顶放在单链表的头部（如图所示）。由于将栈顶放在链表头部了，则单链表的头结点就失去了意义，通常对于链栈来说，是不需要头结点的。

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

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

       链栈结构代码如下所示：

       链栈的操作绝大部分都和单链表类似，只是在插入和删除上特殊一些。

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

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

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

       链栈的出栈pop操作，假设变量p用来存储要删除的栈顶结点，将栈顶指针下移一位，最后释放p即可，

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

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

4.7 栈的作用

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

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

4.8 栈的应用——递归

       递归是栈在程序设计语言中一个很重要的应用。

       递归：一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

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

4.8.1 斐波那契数列的实现

4.8.2 递归定义

       递归函数：把一个直接调用自己或通过一系列的调用语句间接地调用自己的函数，称为递归函数。

       写递归程序最怕的就是陷入永不结束的无穷递归中，所以，每个递归定义必须至少有一个条件，满足时递归不再进行，即不再引用自身而是返回值退出。

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

       递归过程中退回的顺序是它前行顺序的逆序。在退回过程中，可能要执行某些动作，包括恢复在前行过程中存储起来的某些数据。

       这种存储某些数据，并在后面存储的逆序恢复这些数据，已提供之后使用的需求，很符合栈这样的数据结构。

       简单的说，就是在前行阶段，对于每一层递归，函数的局部变量、参数值以及返回地址都被压入栈中。在退回阶段，位于栈顶的局部变量、参数值、和返回地址被弹出，用于返回调用层次中执行代码的其余部分，也就是恢复了调用的状态。现在的高级语言，递归问题的栈都有系统自动管理。

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

4.9.1 后缀（逆波兰）表示法定义

      栈现实中比较常见的一个应用：数学表达式的求值。

       四则运算：加减乘除和括号。

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

       “9+3（3-1）*3+10/2”用后缀表达式的样子为：“9 3 1 – 3 * + 10 2 / +”，叫后缀的原因在于所有的符号都是在要运算数字的后面出现。

4.9.2 后缀表达式计算结果

 

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

       平时所用的标准四则运算表达式，即“9+3（3-1）*3+10/2”叫做中缀表达式。因为所有的运算符号都在两数字的中间。

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

       1.将中缀表达式转化为后缀表达式（栈用来进出 运算的符号）。

       2.将后缀表达式进行运算得出结果（栈用来进出 运算的数字）。

       整个过程充分利用了栈的后进先出的特性来处理，理解好它其实也就是理解好了栈这个数据结构。

4.10 队列的定义

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

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

       队列在程序设计中使用的非常频繁。除了前面的例子，还有比如用键盘进行各种字母或者数字的输入，到显示器上如记事本软件的输出，其实就是队列的典型应用。

4.11 队列的抽象数据类型

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

4.12 循环队列

       线性表有顺序存储和链式存储，栈是线性表，所以有两种顺序存储方式。同样的，队列作为一种特殊的线性表，也存在这两种存储方式。

4.12.1 队列顺序存储的不足

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

       与栈不同的是，队列元素的出栈是在队头，即下标为0的位置，也就意味着，队列中的所有元素都要向前移动，以保证队列的队头，也就是下标为0的位置不为空，此时时间复杂度为O（n），如图所示：

       这个过程的实现和线性表顺序存储结构完全相同。

       在现实中也是和上述一样，一群人买票，前面的人买好了离开，后面的人就要全部向前一步，补上空位，似乎这也没什么不好。

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

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

       假设长度为5的数组，初始状态，如下图左图所示，front与rear指针均指向下标为0的位置。然后a1、a2、a3、a4依次入队，front指针依然指向下标为0的位置，而rear指针指向下标为4也就是a4后面下一个元素的位置，如下图右图所示：

       出队a1、a2后,则front指针向下标为2的位置也就是元素a3所在的位置，rear位置不变，如下图左图所示，再入队元素a5时，此时front指针不变，rear指针移动到数组之外了，由于数组长度为5，那数组长度之外，将会是哪里？如下图右图所示：

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

       现实生活中，你上了公交车，发现前排有两个空座位，而后排所有座位都已经坐满，你会怎么做？立马下车，并对自己说后面没座位了，我等下一辆？没有那么笨的人，前面有座位，当然也是可以坐的，除非满了，才会考虑下一辆。

       为解决这个问题，就出现了循环队列。

4.12.2 循环队列定义

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

       继续上面的例子，在入队a5之后，rear指针可以改为指向下标为0的位置，这样就不会造成指针指向不明的问题了，如下图所示：

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

       ■ 此时问题又出来了，我们刚才说，空队列时，front等于rear，而现在当队列满时，也是front等于rear，那么如何判断此时队列究竟是空还是满呢？

       ■办法一：设置一个标志变量flag，当front==rear，且flag=0时，队列空；当front==rear，且flag=1时，队列满。

       ■办法二：当队列空时，条件就是front==rear；当队列满时，我们修改其条件，保留一个元素空间。也就是说，队列满时，数组中还有一个空闲单元。如下图所示，我们就认为此队列已经满了，也就是说，我们不允许上图右图情况出现的。

       我们重点讨论第二种方法，由于rear可能比front小，所以尽管它们只是相差一个位置就是满的情况但也可能相差整整一圈。所以若队列的最大尺寸为QueueSize，那么队列满的条件就是（rear+1）%QueueSize==front（取模“%”的目的就是为了整合rear与front大小为一个问题）。比如上面的这个例子QueueSize=5，上图的左图front=0，而rear=4，（4+1）%5=0，所以此时队列满。上图的右图，front=2，而rear=1，（1+1）%5=2，所以此时队列也是满的。而对于front=2，而rear=0，（0+1）%5=1,1≠2，所以此时队列并没有满。

       另外，当rear>front是，即下图所示，此时队列的长度为rear-front。

 

       但是当rear

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

       （rear-front+QueueSize）%QueueSize

       有了上面的讲解，现在实现循环队列的代码就不难了。

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

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

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

 

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

       循环队列的出队列操作代码如下：

       从上面的讲解，大家可以发现，单是顺序存储，若不是循环队列，算法的时间性能是不高的，但循环队列又面临着数组可能会溢出的问题。所以我们还需要研究一下不需要担心队列长度的链式存储结构。

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

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

       空队列时，front和rear都指向头结点，如图所示：

       链队列的结构：

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

       入队时，其实就是在链表尾部插入结点，如图所示：

       其代码如下所示：

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

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

       代码如下所示：

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

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

4.14 总结回顾

       这一章讲的是栈与队列，他们都是特殊的线性表，只不过对插入和删除操作做了限制。

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

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

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

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

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

       它们也都可以通过链式存储结构来实现，实现原理与线性表基本相同，如下图所示：

 

 

注：本博客是本人在学习《大话数据结构》后整理的笔记，用于自己以后的复习与回顾，博客中的照片是本人从《大话数据结构》中截取的。