数据结构-栈与队列

栈的定义

栈是限定仅在表尾进行插入和删除操做的线性表

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

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

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

栈的插入操做，叫作进栈，也称压栈、入栈。相似子弹入弹夹，如图4-2-2所示。

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

进栈出栈变化形式

如今我要问问你们，这个最早进栈的元素，是否是就只能是最后出战呢? 答案是不必定，要看什么状况。栈对线性表的插入和删除的位置进行了限制 ，并无对元素进出的时间进行限制，也就是说，在不是全部元素都进栈的状况下，事先进去的元素也能够出栈，只要保证是栈顶元素出栈就能够。

举例来讲，若是咱们如今是有 3 个整型数字元素 一、 二、 3 依次进栈，会有哪些出栈次序呢?

有没有多是 312 这样的次序出栈呢？答案是确定不会。由于 3 先出栈，就意味着，3曾经进栈，既然 3 都进栈了，那也就意味着， 1 和 2 已经进栈了，此时， 2 一 定是在 1 的上面，就是更接近栈顶，那么出栈只多是 321，否则不知足 123 依次进栈的要求，因此此时不会发生1比2先出栈的状况。

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

栈的抽象数据类型

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

因为栈自己就是一个线性表，那么上一章咱们讨论了线性表的顺序存储和链式存储，对于栈来讲，也是一样适用的。

栈的顺序存储结构及实现

栈的顺序存储结构

栈的顺序存储其实也是线性表顺序存储的简化，咱们简称为顺序栈。线性表是用数组来实现的，用下标0的一端做为栈底。由于首元素都在栈底，变化最小，因此让它做栈底。

定义一个top变量来指示栈顶元素在数组中的位置。存储栈的长度胃StackSize，则栈顶位置top必须小于StackSize。当栈存在一个元素时，top等于0，所以一般把空栈的判断条件定为top=-1。

若如今有一个栈，StackSize是5，则栈普通状况、空栈和栈满的状况示意图如图4-4-2所示。

栈的顺序存储结构一一进栈操做

栈的顺序存储结构一一出栈操做

二者没有涉及到任何循环语句，所以时间复杂度O(1)。

两栈共享空间

栈的顺序存储是很方便，由于它只准栈顶进出元素，因此不存在线性表插入和删除时须要移动元素的问题。不过它有一个很大的缺陷，就是必须实现肯定数组存储空间大小，万一不够用了，就须要编码手段来扩展数组的容量，很是麻烦。对于一个栈，咱们也只能尽可能考虑周全，设计出合适大小的数组来处理，但对于两个相同类型的栈，咱们却能够作到最大限度地利用其事先开辟的存储空间来进行操做。 若是咱们有两个相同类型的栈，咱们为它们各自开辟了数组空间，极有多是第一个栈已经满了，再进栈就溢出了，而另外一个栈还有不少存储空间空闲。这又何须呢？咱们彻底能够用一个数组来存储两个栈，只不过须要一点技巧。 咱们的作法如图4-5-1，数组有两个端点，两个栈有两个栈底，让一个栈的栈底为数组的始端，即下标为0处，另外一个栈为栈的末端，即下标为数组长度n-1处。这样，两个栈若是增长元素，就是两端点向中间延伸。

关键思路是：它们是在数组的两端，向中间靠拢。top1和top2是栈1和栈2的栈顶指针，能够想象，只要它们俩不见面，两个栈就能够一直使用。 从这里也能够分析出，栈1为空时，就是top1=-1时；而当top2=n时，便是栈2为空时，那何时栈满呢？ 想一想极端的状况，若栈2是空栈，栈1的 top1 等于 n-1 时，就是栈1满了。 反之，当栈1为空栈时， top2等于0时，为栈2满。但更多的状况，其实就是我刚才说的，两个栈见面之时，也就是两个指针之间相差 1 时，即top + 1 == top2为栈满。

对于两栈共享空间的 push 方法，咱们除了要插入元素值参数外，还须要有一个判断是栈1仍是栈2的栈号参数 stackNumber。

使用这样的数据结构，一般都是当两个栈的空间需求有相反关系时，也就是一个栈增加时另外一个栈在缩短的状况。这样使用两栈共享存储方法才有比较大的意义。不然两个栈都在不停地增加，那很快就会因栈满而溢出。

固然这只针对两个具备相同数据类型的栈的一个设计上的技巧，若是是不相同数据类型的栈，这种办法不但不能更好地处理问题，反而会使问题变得更复杂，要注意这个前提。

栈的链式存储结构及实现

栈的链式存储结构

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

想一想看，栈只是栈顶来作插入和删除操做，栈顶放在链表的头部仍是尾部呢?因为单链表有头指针，而栈顶指针也是必须的，那干嘛不让它俩合二为一呢，因此比较好的办法是把栈顶放在单链表的头部(如图 4-6-1 所示)。另外，都已经有了栈顶在头部了，单链表中比较经常使用的头结点也就失去了意义，一般对于链栈来讲，是不须要头结点的。

对于链栈来讲，基本不存在栈满的状况，除非内存已经没有可使用的空间，若是真的发生，那此时的计算机操做系统已经面临死机崩溃的状况，而不是这个链栈是否溢出的问题。 但对于空栈来讲，链表原定义是头指针指向空，那么链栈的空其实就是 top=NULL的时候。

栈的链式存储结构一一进栈操做

对于链栈的进栈 push 操做，假设元素值为 e 的新结点是 S， top 为栈顶指针，示意图如图 4-6-2 所示代码以下。

栈的链式存储结构一一出栈操做

假设变量 p 用来存储要删除的钱顶结点，将栈顶指针下移一位，最后释放 p 便可，如图 4-6-3 所示。

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

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

栈的做用

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

因此如今的许多高级语言，好比 )ava、 C#等都有对栈结构的封装， 你能够不用关注它的实现细节，就能够直接使用 Stack 的 push 和 pop 方法，很是方便。

栈的应用一一递归

递归的定义

咱们把一个直接调用本身或经过一系列的调用语句间接地调用本身的函数，称作递归函数。

队列(queue)是只容许在一端进行插入操做，而在另外一端进行删除操做的线性表。 队列是一种先进先出(First In First Out)的线性表，简称FIFO。容许插入的一端称为队尾，容许删除的一端称为队头。

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

选代和递归的区别是:迭代使用的是循环结构，递归使用的是选择结构。递归能使程序的结构更清晰、更简洁、更容易让人理解，从而减小读懂代码的时间。可是大量的递归调用会创建函数的副本，会耗费大量的时间和内存。选代则不须要反复调用函数和占用额外的内存。所以咱们应该视不一样状况选择不一样的代码实现方式。

递归与栈之间有什么关系？

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

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

简单的说，就是在前行阶段，对于每一层递归，函数的局部变量、参数值以及返 回地址都被压入栈中。在退回阶段，位于栈顶的局部变量、 参数值和返回地址被弹 出，用于返回调用层次中执行代码的其他部分，也就是恢复了调用的状态。

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

后缀(逆波兰)表示法定义

咱们举个例子，对于"9+ (3-1) X3+10-:-2"，若是要用后缀表示法应该是什么样子:"931-3*+102/+"，这样的表达式称为后缀表达式，叫后缀的缘由在于全部的符号都是在要运算数字的后面出现。显然，这里没有了括号。

后缀表达式计算结果

为了解释后缀表达式的好处，咱们先来看看，计算机是如何应用后缀表达式计算最终的结果20的。 后缀表达式：931-3*+102/+ 规则：:从左到右遍历表达式的每一个数字和符号，遇到是数字就进枝，遇到是符号，就将处于桔顶两个数字出拢，进行运算，运算结果进钱，一直到最终得到结果。

1. 初始化一个空技J 此钱用来对要运算的数字进出使用。如图4-9-1的左图所示
2. 后缀表达式中前三个都是数字，因此九、三、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的右图所示。

中缀表达式转后缀表达式（具体百度）

队列的定义

队列 ( queue ) 是只容许在一端进行插入操做，而在另外一端进行删除操做的线性表。 队列是一种先进先出 (First In First Out) 的线性表，简称 FIFO。容许插入的一端称为队尾，容许删除的一端称为队头。

队列的抽象数据类型

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

循环队列

线性表有顺序存储和链式存储，栈是线性表，因此有这两种存储方式。一样，队列做为一种特殊的线性表，也一样存在这两种存储方式。先来看队列的顺序存储结构

队列顺序存储的不足

咱们假设一个队列有 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 的位置。 而后入队 a一、 a二、 a三、 a4， front 指针依然指向下标 为 0 位置，而 rear 指针指向下标为 4 的位置，如图 4-12-4 的右图所示。

出队 a一、 a2，则 front指针指向下标为 2 的位置， rear 不变，如图 4-12-5 的左图所示，再入队 a5，此时 front 指针不变， rear 指针移动到数组以外。嗯?数组以外， 那将是哪里?如图 4-12-5 的右图所示。

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

循环队列定义

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

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

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

• 此时问题又出来了，咱们刚才说，空队列时， fronr =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 = 5，图 4-12-8 的左图中 front=0，而 rear=4， (4+1) %5 = 0，因此此时队列满. 再好比图 4-12-8 中的右图， front = 2 而 rear = 1。 (1 + 1) %5 = 2 ，因此此时 队列也是满的。而对于图 4-12-6， front=2 而 rear= 0 , (0+1) %5 = 1 , 1 ≠ 2，因此此时队列并无满。

另外，当 rear> front 时，即图 4-12-4 的右图和 4-12-5 的左图，此时队列的长度 为 rear-front 但当 rear < front 时，如图 4-12-6 和图 4-12-7 的左图，队列长度分为 两段， 一段是 QueueSize-front， 另外一段是 0 + rear，加在一块儿，队列长度为 rear-front + QueueSize。所以通用的计算队列长度公式为: (rear- front + QueueSize) %QueueSize

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

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

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

队列的链式存储结构一一入队操做

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

队列的链式存储结构一一出队操做

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

对于循环队列与链队列的比较，能够从两方面来考虑，从时间上，其实它们的基 本操做都是常数时间，即都为 0(1)的，不过循环队列是事先申请好空间，使用期间不释放，而对于链队列，每次申请和释放结点也会存在一些时间开销，若是入队出队频 繁，则二者仍是有细微差别。对于空间上来讲，循环队列必须有一个固定的长度，因此就有了存储元素个数和空间浪费的问题。而链队列不存在这个问题，尽管它须要一个指针域， 会产生一些空间上的开销，但也能够接受。 因此在空间上，链队列更加灵活。 总的来讲，在能够肯定队列长度最大值的状况下 ，建议用循环队列，若是你没法预估队列的长度时，则用链队列。

总结

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

栈 (stack) 是限定仅在表尾进行插入和删除操做的线性袭。

队列 (queue) 是只容许在一端进行插入操做，而在另外一端进行删除操做的线性表。

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

所以它们各自有各自的技巧来解决这个问题。

对于栈来讲，若是是两个相同数据类型的栈，则能够用数组的两端做栈底的方法来让两个栈共享数据，这就能够最大化地利用数组的空间。 对于队列来讲，为了不数组插入和删除时须要移动数据，因而就引入了循环队列 ，使得队头和队尾能够在数组中循环变化。解决了移动数据的时间损耗，使得原本插入和删除是 O(n)的时间复杂度变成了O(1)。 它们也均可以经过链式存储结构来实现，实现原则上与线性表基本相同如图 4-14-1 所示。

参考：《大话数据结构》

感谢你花时间读到结尾！：D

后端一枚，默默搬砖撸代码，若是以为不错欢迎关注个人公众号