栈

【知识框架】

 

 

 

一、栈的基本概念

1、栈的定义

栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。

栈顶（Top）：线性表允许进行插入删除的那一端。

栈底（Bottom）：固定的，不允许进行插入和删除的另一端。

空栈：不含任何元素的空表。

栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构

2、栈的常见基本操作

  • InitStack(&S)：初始化一个空栈S。
  • StackEmpty(S)：判断一个栈是否为空，若栈为空则返回true，否则返回false。
  • Push(&S, x)：进栈（栈的插入操作），若栈S未满，则将x加入使之成为新栈顶。
  • Pop(&S, &x)：出栈（栈的删除操作），若栈S非空，则弹出栈顶元素，并用x返回。
  • GetTop(S, &x)：读栈顶元素，若栈S非空，则用x返回栈顶元素。
  • DestroyStack(&S)：栈销毁，并释放S占用的存储空间（“&”表示引用调用）。

二、栈的顺序存储结构

1、栈的顺序存储

采用顺序存储的栈称为顺序栈，它利用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时附设一个指针（top）指示当前栈顶元素的位置。
若存储栈的长度为StackSize，则栈顶位置top必须小于StackSize。当栈存在一个元素时，top等于0，因此通常把空栈的判断条件定位top等于-1。
栈的顺序存储结构可描述为：

1 #define MAXSIZE 50  //定义栈中元素的最大个数
2 typedef int ElemType;   //ElemType的类型根据实际情况而定，这里假定为int
3 typedef struct{
4     ElemType data[MAXSIZE];
5     int top;    //用于栈顶指针
6 }SqStack;

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

2、顺序栈的基本算法 

（1）初始化

1 void InitStack(SqStack *S){
2     S->top = -1;    //初始化栈顶指针
3 }

（2）判栈空

1 bool StackEmpty(SqStack S){
2     if(S.top == -1){    
3         return true;    //栈空
4     }else{  
5         return false;   //不空
6     }
7 }

（3）进栈

 

 

 

进栈操作push，代码如下：

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

 

（4）出栈

出栈操作pop，代码如下：

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

 

（5）读栈顶元素

1 /*读栈顶元素*/
2 Status GetTop(SqStack S, ElemType *e){
3     if(S->top == -1){   //栈空
4         return ERROR;
5     }
6     *e = S->data[S->top];   //记录栈顶元素
7     return OK;
8 }

 

3、共享栈（两栈共享空间）

（1）共享栈概念

利用栈底位置相对不变的特征，可让两个顺序栈共享一个一维数组空间，将两个栈的栈底分别设置在共享空间的两端，两个栈顶向共享空间的中间延伸，如下图所示：

 

 

 

两个栈的栈顶指针都指向栈顶元素，top0=-1时0号栈为空，top1=MaxSize时1号栈为空；仅当两个栈顶指针相邻（top0+1=top1）时，判断为栈满。当0号栈进栈时top0先加1再赋值，1号栈进栈时top1先减一再赋值出栈时则刚好相反。

（2）共享栈的空间结构

代码如下：

1 /*两栈共享空间结构*/
2 #define MAXSIZE 50  //定义栈中元素的最大个数
3 typedef int ElemType;   //ElemType的类型根据实际情况而定，这里假定为int
4 /*两栈共享空间结构*/
5 typedef struct{
6     ElemType data[MAXSIZE];
7     int top0;    //栈0栈顶指针
8     int top1;    //栈1栈顶指针
9 }SqDoubleStack;

 

（3）共享栈进栈

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

共享栈进栈的代码如下：

 1 /*插入元素e为新的栈顶元素*/
 2 Status Push(SqDoubleStack *S, Elemtype e, int stackNumber){
 3     if(S->top0+1 == S->top1){   //栈满
 4         return ERROR;
 5     }
 6     if(stackNumber == 0){   //栈0有元素进栈
 7         S->data[++S->top0] = e; //若栈0则先top0+1后给数组元素赋值
 8     }else if(satckNumber == 1){ //栈1有元素进栈
 9         S->data[--S->top1] = e; //若栈1则先top1-1后给数组元素赋值
10     }
11     return OK;
12 }

 

（4）共享栈出栈

代码如下：

 1 /*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
 2 Status Pop(SqDoubleStack *S, ElemType *e, int stackNumber){
 3     if(stackNumber == 0){
 4         if(S->top0 == -1){
 5             return ERROR;   //说明栈0已经是空栈，溢出
 6         }
 7         *e = S->data[S->top0--]; //将栈0的栈顶元素出栈，随后栈顶指针减1
 8     }else if(stackNumber == 1){
 9         if(S->top1 == MAXSIZE){
10             return ERROR;   //说明栈1是空栈，溢出
11         }
12         *e = S->data[S->top1++];    //将栈1的栈顶元素出栈，随后栈顶指针加1
13     }
14     return OK;
15 }

 


三、栈的链式存储结构

1、链栈

采用链式存储的栈称为链栈，链栈的优点是便于多个栈共享存储空间和提高其效率，且不存在栈满上溢的情况。通常采用单链表实现，并规定所有操作都是在单链表的表头进行的。这里规定链栈没有头节点，Lhead指向栈顶元素，如下图所示。

 

 

 

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

链栈的结构代码如下：

 1 /*栈的链式存储结构*/
 2 /*构造节点*/
 3 typedef struct StackNode{
 4     ElemType data;
 5     struct StackNode *next;
 6 }StackNode, *LinkStackPrt;
 7 /*构造链栈*/
 8 typedef struct LinkStack{
 9     LinkStackPrt top;
10     int count;
11 }LinkStack;

 

2、链栈的基本算法

（1）链栈的进栈

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

 

 

 

代码如下：

1 /*插入元素e为新的栈顶元素*/
2 Status Push(LinkStack *S, ElemType e){
3     LinkStackPrt p = (LinkStackPrt)malloc(sizeof(StackNode));
4     p->data = e;
5     p->next = S->top;    //把当前的栈顶元素赋值给新节点的直接后继
6     S->top = p; //将新的结点S赋值给栈顶指针
7     S->count++;
8     return OK;
9 }

 

（2）链栈的出栈

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

 

 

 

代码如下：

 1 /*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
 2 Status Pop(LinkStack *S, ElemType *e){
 3     LinkStackPtr p;
 4     if(StackEmpty(*S)){
 5         return ERROR;
 6     }
 7     *e = S->top->data;
 8     p = S->top; //将栈顶结点赋值给p
 9     S->top = S->top->next;  //使得栈顶指针下移一位，指向后一结点
10     free(p);    //释放结点p
11     S->count--;
12     return OK;
13 }

 

3、性能分析

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

 

四、栈的应用——递归

1、递归的定义

递归是一种重要的程序设计方法。简单地说,若在一个函数、过程或数据结构的定义中又应用了它自身,则这个函数、过程或数据结构称为是递归定义的,简称递归。
它通常把一个大型的复杂问题层层转化为一个与原问题相似的规模较小的问题来求解,递归策略只需少量的代码就可以描述岀解题过程所需要的多次重复计算,大大减少了程序的代码量但在通常情况下,它的效率并不是太高。

2、斐波那契数列

在解释斐波那契数列之前，我们想看经典的兔子繁殖的问题：

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

第一个月初有一对刚诞生的兔子
第二个月之后（第三个月初）它们可以生育
每月每对可生育的兔子会诞生下一对新兔子
兔子永不死去

我们拿新出生的一对小兔子分析一下:第一个月小兔子没有繁殖能力,所以还是一对;两个月后,生下一对小兔子数共有两对;三个月以后,老兔子又生下一对,因为小兔子还没有繁殖能力,所以一共是三对…依次类推得出这样一个图：

 

 从这个图可以看出，斐波那契数列数列有一个明显的特点，即：前面两项之和，构成了后一项。

如果用数学函数定义斐波那契数列，那就是：

 

 

而这个，就是递归的一个典型例子，用程序实现时如下：

 1 /*斐波那契数列的实现*/
 2 int Fib(int n){
 3     if(n == 0){
 4         return 0;   //边界条件
 5     }else if(n == 1){
 6         return 1;    //边界条件
 7     }else{
 8         return Fib(n-1) + Fib(n-2); //递归表达式
 9     }
10 }

必须注意递归模型不能是循环定义的,其必须满足下面的两个条件

  • 递归表达式(递归体)
  • 边界条件(递归出口)

递归的精髓在于能否将原始问题转换为属性相同但规模较小的问题
在递归调用的过程中,系统为每一层的返回点、局部变量、传入实参等开辟了递归工作栈来进行数据存储,递归次数过多容易造成栈溢出等。而其效率不高的原因是递归调用过程中包含很多重复的计算。下面以n=5为例,列出递归调用执行过程,如图所示：

如图可知，程序每往下递归一次，就会把运算结果放到栈中保存，直到程序执行到临界条件，然后便会把保存在栈中的值按照先进后出的顺序一个个返回，最终得出结果。

 

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

1、后缀表达式计算结果

表达式求值是程序设计语言编译中一个最基本的问题,它的实现是栈应用的一个典型范例。中缀表达式不仅依赖运算符的优先级,而且还要处理括号。后缀表达式的运算符在操作数后面，在后缀表达式中已考虑了运算符的优先级,没有括号,只有操作数和运算符。例如中缀表达式A + B ∗ ( C − D ) − E / F所对应的后缀表达式为A B C D − ∗ + E F / − 。

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

后缀表达式A B C D − ∗ + E F / − 求值的过程需要12步，如下表所示：

 

 读者也可将后缀表达式与原运算式对应的表达式树(用来表示算术表达式的二元树)的后序遍历进行比较,可以发现它们有异曲同工之妙。

如下图则是A + B ∗ ( C − D ) − E / F A+B*(C-D)-E/FA+B∗(C−D)−E/F对应的表达式，它的后序遍历即是表达式A B C D − ∗ + E F / − ABCD-*+EF/-ABCD−∗+EF/−。

 

 

2、中缀表达式转后缀表达式

我们把平时所用的标准四则运算表达式,即a + b − a ∗ ( ( c + d ) / e − f ) + g 叫做中缀表达式。因为所有的运算符号都在两数字的中间,现在我们的问题就是中缀到后缀的转化。

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

例：将中缀表达式a + b − a ∗ ( ( c + d ) / e − f ) + g 转化为相应的后缀表达式。

分析：需要根据操作符

的优先级来进行栈的变化,我们用icp来表示当前扫描到的运算符ch的优先级,该运算符进栈后的优先级为isp,则运算符的优先级如下表所示[isp是栈内优先( in stack priority)数,icp是栈外优先( in coming priority)数]。

 

我们在表达式后面加上符号‘#’,表示表达式结束。具体转换过程如下：

 

 即相应的后缀表达式为a b + a c d + e / f − ∗ − g + 。

 

 
posted @ 2022-11-09 11:27  随手一只风  阅读(567)  评论(0)    收藏  举报