《大话数据结构》之栈与队列

自己在看《大话数据结构》这本书，顺便需要练习使用博客，就顺便把自己的读书笔记发上来啦。

栈的定义

手枪：先进的子弹后打出
栈(stack)是限定仅在表尾(栈顶)进行插入和删除操作的线性表。
（浏览器：后退键和文档或图片编辑软件：撤销操作(undo)) 都是栈的应用。
我们把允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)。栈又称为后进先出(List In First Out)的线性表，简称LIFO结构。
首先栈是一个线性表，也就是说，栈元素具有线性关系，即前驱后继关系。它是特殊的线性表，特殊之处在于限制了这个线性表的插入和删除位置，它始终只在栈顶进行。这就使得，栈底是固定的，最先进栈的只能在栈底。

进栈出栈形式变化

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

栈的抽象数据类型

push和pop
其他同线性表

栈的顺序存储结构及实现

栈的顺序存储结构

栈的顺序存储是线性表顺序存储的简化，简称为顺序栈。
线性表是用数组来实现的，对于栈这种只能一头插入删除的线性表来说，用数组下标为0的一端作为栈底比较好，因为首元素都存在栈底，变化最小。
定义一个top变量来指示栈顶元素在数组中的位置，top可以变大变小，但不能超过存储栈的长度StackSize，即top必须小于StackSize。当栈中存在一个元素时，top等于0，因此通常把空栈的判定条件定为top等于-1。

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

push

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

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

两栈共享空间

栈的顺序存储结构因为只准栈顶进出元素，所以不存在线性表插入和删除时需要移动元素的问题。不过它的缺陷是必须事先确定数组存储空间大小。
对于一个栈，我们尽量设计出合适大小的数组来处理，但对于两个相同类型的栈，我们却可以做到最大限度地利用其事先开辟的存储空间来进行操作。
如果有两个相同类型的栈，我们完全可以用一个数组来存储两个栈。
数组有两个端点，两个栈有两个栈底，让一个栈的栈底为数组的始端，即下标为0处，另一个栈的栈底为数组的末端，即下标为数组长度 n-1 处。这样，两个栈如果增加元素，就是两端点向中间延伸。

其中关键思路是：它们是在数组的两端，向中间靠拢。top1 和 top2 是栈 1 和栈 2 的栈顶指针，可以想象，只要它们两个不见面，两个栈就可以一直使用。
当 top1 = -1，即栈 1 为空；
当 top2 = n， 即栈 2 为空；
极端情况下，若栈 2 为空栈，top1 等于 n-1 时，说明栈1 满了；
当 栈 1 为空栈时，top2 等于 0 时，栈 2 满了；
其他情况下，两栈见面时，也就是两个栈的指针之间相差 1 时，即 top1 + 1 == top2 为栈满。
对于两栈共享空间的 push 方法，我们除了要插入元素值参数外，还需要有一个判断栈 1 还是栈 2 的栈号参数stackNumber。在开始的时候会判断是否栈满，后面的 top1 + 1 或 top2 - 1 是不担心溢出问题的。
对于两栈共享的pop方法，参数就只是判断栈 1 栈 2的参数stackNumber。
事实上，使用这样的数据结构，通常都是当两个栈的空间需求有相反关系时，也就是一个栈增长时另一个栈在缩短的情况。

栈的链式存储结构及实现

栈的链式存储结构

简称为链栈
栈只是栈顶来做插入和删除操作，而单链表有头指针，而栈顶指针也是必须的，何不合二为一呢。
所以把栈顶放在单链表的头部，此时单链表的头结点就失去了意义，所以链栈不需要头结点。
链栈基本不存在栈满的情况。
空栈，链表原定义是头指针指向空，那么链栈的空就是
top = NULL的时候。
链栈的绝大多数操作与单链表类似，只是在插入和删除上，特殊一些。

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

进栈push操作：
把当前的栈顶元素赋值给新结点的直接后继；
将新的结点s赋值给栈顶指针。

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

出栈pop操作：
假设变量 p 用来存储要删除的栈顶结点，将栈顶指针下移一位，最后释放 p 即可。
push和pop的时间复杂度都是O(1)。

对比一下顺序栈和链栈，它们在时间复杂度上是一样的，均为O(1)。对于空间性能，顺序栈需要事先确定一个固定的长度，可能会存在内存空间浪费的问题，但它的优势是存取时定位很方便，而链栈则要求每个元素都有指针域，这同时也增加了一些内存开销，但对于栈的长度无限制。

栈的作用

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

栈的应用——递归

“像中像”
经典的递归例子——斐波那契数列(Fibonacci)。

斐波那契数列实现

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

表中数字1，1，2，3，5，8，13…构成了一个序列，特点是：前面相邻两项之和，构成了后一项。

int Fbi(int i)
{
  if(i < 2)
     return i == 0 ? 0 : 1;
  return Fbi (i - 1) + Fbi (i - 2);
}

模拟代码中当 i= 5时的执行过程

递归定义

在高级语言中，调用自己和其他函数并没有本质的不同。把一个直接调用自己或通过一系列的调用语句间接地调用自己的函数，称做递归函数。
每个递归定义必须至少有一个条件，满足时递归不再进行，即不再引用自身而是返回值退出。
迭代和递归的区别是：迭代使用的是循环结构，递归使用的是选择结构。递归能使程序的结构更清晰、更简洁、更容易让人理解，从而减少读代码的时间。但是大量的递归调用会建立函数的副本，会耗费大量的时间和内存。迭代不需要反复调用函数和占用额外的内存。应该视不同情况不同选择。

递归与栈的关系，需要从计算机系统的内部说起。
递归包括前行和退回阶段。递归过程退回的顺序是它前行顺序的逆序。在退回过程中，可能要执行某些动作，包括恢复在前行过程中存储起来的某些数据。
这种存储某些数据，并在后面又以存储的逆序恢复这些数据，，以提供之后使用的需求，显然很符合栈的数据结构。因此，编译器使用栈实现递归。
简单的说，就是在前行阶段，对于每一层递归，函数的局部变量、参数值以及返回地址都被压入栈中。在退回阶段，位于栈顶的局部变量、参数值和返回地址被弹出，用于返回调用层次中执行代码的其余部分，也就是恢复了调用的状态。
对于现在的高级语言，这样的递归问题是不需要用户来管理这个栈的，系统代劳了。

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

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

栈的现实应用：数学表达式的求值。
对于有括号的四则运算，仔细观察后发现，括号都是成对出现的，有左括号就一定有右括号，对于多重括号，最终也是完全嵌套匹配的。这用栈结构正好合适，只要碰到左括号，就将此左括号进栈，不管表达式有多少重括号，反之遇到左括号就进栈，而后面出现右括号时，就让栈顶的左括号出栈，期间让数字运算，这样，最终有括号的表达式从左到右巡查一遍，栈应该是由空到有元素，最终再因全部匹配成功后成为空栈的结果。
不需要括号的后缀表达法，也成为逆波兰(RPN)表示这种后缀表示法，是表达式的一种新的显示方式，非常巧妙地解决了程序实现四则运算的难题。
9 + (3 - 1) ✖ 3 + 10 ➗ 2
用后缀表示法：9 3 1 - 3* + 10 2 / +
所有的符号都是在要运算数字的后面出现。

后缀表达式计算结果

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

中缀表达式转后缀表达式

标准四则运算表达式即"9 + (3 - 1) ✖ 3 + 10 ➗ 2"叫做中缀表达式。
中缀表达式“9 + (3 - 1) ✖ 3 + 10 ➗ 2”转后缀表达式“9 3 1 - 3* + 10 2 / + ”
规则：从左到右遍历中缀表达式的每个数字和符号，若是数字就输出，即成为后缀表达式的一部分；若是符号，则判断其与栈顶符号的优先级，是右括号或优先级低于栈顶符号(乘除优先加减)则栈顶元素依次出栈并输出，并将当前符号进栈，一直到最终输出后缀表达式为止。
注意：当当前符号比栈顶元素的优先级低时，栈中元素出栈并输出（没有比当前符号更低的优先级(哪怕栈里有和当前符号同级的)，所以全部出栈）然后再将当前符号入栈。
要想让计算机具有处理我们通常的标准(中缀)表达式的能力，最重要的就是两步：

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

整个过程，都充分利用栈先进后出的特性。

队列的定义

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

循环队列

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

队列顺序存储的不足

入队操作，在队尾追加一个元素，不需要移动任何元素，时间复杂度为O(1)。
出队操作是在队头，队列中所有元素都得向前移，时间复杂度为O(n)。
可为什么出队时一定要全部移动呢，如果不去限制队列的元素必须存储在数组的前n个单元这一条件，出队的可能性就会大大增加。也就是说，队头不需要一定在下标为0的位置。
为了避免当只有一个元素时，队头和队尾重合使处理变得麻烦，所以引入两个指针，front 指针指向队头元素，rear 指针指向队尾元素的下一个位置，这样当front 等于 rear 时，此队列不是还剩一个元素，而是空队列。
“假溢出”

循环队列定义

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

如何判断 front == rear 时队列是空还是满：
方法一：设置一个标志变量 flag，当 front == rear，且 flag = 0时为队列空，当 front == rear，且 flag = 1时为队列满。
方法二：当队列空时，条件就是front == rear，当队列满时，我们修改其条件，保留一个元素空间。也就是说，队列满时，数组中还有一个空闲单元。
方法二中，由于rear可能比front大，也可能比front小，所以尽管它们只相差一个位置时就是满的情况，但也可能是相差整整一圈。所以若队列的最大尺寸为QueueSize，那么队列满的条件是 (rear + 1) % QueueSize == front(取模“%”的目的就是为了整合 rear 与 front 大小为一个问题)(这个式子也用来计算循环时从最后转到头部时rear或front的位置)。
通用的计算队列长度公式为：
(rear - front + QueueSize) % QueueSize

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

队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列。
我们将队头指针指向链队列的头结点而队尾指针指向终端结点。
空队列时，front 和 rear 都指向头结点。

链队列的数据结构分为结点结构和链表结构。

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

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

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

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

总结回顾

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