《大话数据结构》读书笔记-栈与队列

写在前面：本文仅供个人学习使用。《大话数据结构》通俗易懂，适合整体做笔记输出，构建体系。并且文中很多图片来源于该书。

文章目录

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.13 队列的链式存储结构及实现
4.14总结回顾

栈与队列：
1 栈是限定仅在表尾进行插入和删除操作的线性表。
2 队列是指允许在一端进行插入操作、而在另一端进行删除操作的线性表。

4.2栈的定义

4.2.1 栈的定义

栈是类似弹夹中的子弹一样先进去、后出来；而后进的，反而可以先出来。

在软件应用中，栈这种后进先出的数据结构的应用是非常普遍的。比如用浏览器上网时，不管什么浏览器都有一个 “后退”键，点击后就可以按访问顺序的逆序加载浏览过的网页。很多类似的软件，比如word、ps等文档或图像编辑软件中，都有撤销的操作，也是用栈这种方式来实现的。栈(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同线性表。元素具有相同的类型，相邻元素具有前驱和后继的关系。
OperationInitStack(*S):初始化操作，建立一个空栈SDestroyStack(*S):若栈存在，则销毁它。ClearStack(*S):将栈清空StackEmpty(S):若栈为空，返回true；否则返回falseGetTop(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变量来指示栈顶元素在数组中的位置，可以变大变小，但是不饿能超过范围。如果存储栈的长度为StackSize，则栈顶位置top必须小于StackSize，当栈存在一个元素时，top=0，因此通常把空栈的判定条件定为top等于-1.

来看栈的结构定义

typedef int SElemType/
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；否则返回ERRORStatus Pop(SqStack *S,SElemType *e){if(S->top==-1)  return ERROR;*e=S->data[S->top];  S->top--;return OK;}

入栈和出栈没有涉及任何循环结构，因此时间复杂度为O(1).

4.5两栈共享空间

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

打个比方，两个大学室友毕业同时来上海找工作，开始时，他们觉得住了这么多年学校的集体宿舍，现在工作了一定要有自己的私密空间。于是他们都希望租房时能找到独居的一居室，可找来找去却发现，最便宜的一居室也要每月1500元，地段还不好，实在承受不起，最终他俩还是合租了一套两居室，一共2000元，各出一半，还不错。

对于两个一居室，都有独立的卫生间和厨房，是私密了，但大部分空间的利用率却不高。而两居室，两个人各有卧室，还共享了客厅、厨房和卫生间，房间的利用率就显著提高了，而且租房成本也大大下降了。

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

我们的做法如下图所示，数组有两个端点，两个栈有两个栈底，让一个栈的栈底为数组的始端，即下标为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;int top2;//指针}SqDoubleStack;

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

Status Push(SqDoubleStack *S,SElemType e,int stackNumber){if(S->top1+1==S->top2)  return ERROR;//栈满if(stackNumber==1)  //栈1有元素进栈S->data[++S->top1]=e;//++top1是先加再赋值else if(stackNumber==2)//栈2有元素进栈S->data[--S->top2]=e; //top2先-1 然后给数组元素赋值return OK;
}

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

status Pop(SqDoubleStack *S,SElemType *e,int stackNumber){if(stackNumber==1){if(S->top1==-1) return ERROR;*e=S->data[S->top1--];先取出S->top1处的值，再--}else if(stackNumber==2){if(S->top2==MAXSIZE) return ERROR;*e=S->data[S->top2++];}return OK;
}

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

另外，这只是针对两个具有相同数据类型的栈的一个设计上的技巧。如果是不同的数据类型的栈，这种办法不但不嫩更好地处理问题，反而会使问题变得更复杂，大家要注意这个前提。

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

4.6.1 栈的链式存储结构

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

对于链栈来说，基本不存在栈满的情况，除非内存没有可用空间的时候。但对于空栈来说，链表原定义是头指针指向空，那么链栈的空其实就是top==NULL的时候。
链栈的结构代码如下

typedef struct{SElemType data;//数据元素struct StackNode *next;//指针
}StackNode,*LinkStackPtr;typedef struct{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;S->top=s;S->count++;return OK;}

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

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

Status Pop(LinkStack *S ,SElemType *e){LinkStackPtr p;if(StackEmpty(*S)) return ERROR;*e=S->top->data;p=S->top;//将栈顶元素赋给pS->top=S->top->next; //栈顶下移free(p); //释放结点pS->count--;return OK;
}

链栈的进栈和出栈的时间复杂度都是O(1).

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

4.7 栈的应用

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

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

4.8栈的应用–递归

4.8.1 斐波那契数列实现

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

表中数字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;printf("%d",a[0]); printf("%d",a[1]);for(i=2;i<40;i++){a[i]=a[i-1]+a[i-2];printf("%d",a[i]);}return 0;
}

代码很简单，不用做任何解释，但其实我们的代码，如果用递归来实现，还可以更简单。

int Fbi(int i){if(i<2) return i==0 ? 0 :1;reuturn Fbi(i-1)+Fbi(i-2);
}int main(){int i;for(i=0;i<40;i++) printf("%d",Fbi(i));return 0;}

我们来模拟代码中的Fbi(5)的情况

4.8.2递归定义

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

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

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

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

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

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

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

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

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

如果让你用C语言或其他高级语言实现对数学表达式的求值，你打算怎样做？

这里面的困难就在于乘除在加减的后面，却先要运算，而加入了括号后，就变得更加复杂。不知道该如何处理。

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

20世纪50年代，波兰逻辑学家Jan想到了一种不需要括号的后缀表达式，我们也把它称为逆波兰式(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进栈，如图所示

3 接下来是”-“，所以将栈中的1出栈作为减数，3出栈作为被减数，并运算得到2，再将2进栈，如图4-9-2左图所示
4 接着是数字3进栈，如图49-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.如图4-9-8右图所示。

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

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右图所示。

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

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

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

4.10 队列的定义

(待填坑！！！)

你们用电脑时有没有经历过，机器有时会处于疑似死机的状态，鼠标点什么似乎都没有用，双击任何快捷方式都不动弹。就当你失去耐心，打算reset时，它突然像酒醒了一样，把你刚才点击的所有操作全部都按顺序执行了一遍。这其实是因为操作系统中的多个程序因需要通过一个通道输出，而按先后次序排队等待造成的。

4.11 队列的抽象数据类型

4.12 循环队列

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

4.14总结回顾