数据结构与算法之美-栈 （笔记4）

栈

像一堆叠在一起的盘子，放的时候从下往上放，拿的时候往下拿。后进先出，先进后出，这就是栈。从操作特性来看，栈是一种“操作受限”的线性表，只允许在一端插入和删除数据。
事实上，从功能上来说，数组或链表确实可以替代栈，但你要知道，特定的数据结构是对特定场景的抽象，而且，数组或链表暴露了太多的操作接口，操作上的确灵活自由，但使用时就比较不可控，自然也就更容易出错
当某个数据集合只涉及在一端插入和删除数据，并且满足后进先出、先进后出的特性，我们就应该首选“栈”这种数据结构。
如何实现一个“栈”
从刚才栈的定义里，我们可以看出，栈主要包含两个操作，入栈和出栈，也就是在栈顶插入一个数据和从栈顶删除一个数据。理解了栈的定义之后，我们来看一看如何用代码实现一个栈。
实际上，栈既可以用数组来实现，也可以用链表来实现。用数组实现的栈，我们叫作顺序栈，用链表实现的栈我们叫作链式栈。

顺序栈

typedef struct {  
    int data[MAX_SIZE];  
    int top;  
} Stack; 
//初始化
void init(Stack *stack) {  
    stack->top = -1;  
} 
//判空
int is_empty(Stack *stack) {  
    return stack->top == -1;  //返回bool值，如果等式成立返回true
}
//判满
int is_full(Stack *stack) {  
    return stack->top == MAX_SIZE - 1;  
}
//入队判满，出队判空
void push(Stack *stack, int value) {  
    if (is_full(stack)) {  
        printf("Stack is full\n");  
        return; 
    }  
    stack->top++;  //第一个元素为data[0]
    stack->data[stack->top] = value;  
}

链式栈

typedef struct node     
{
    int data; 
    struct node *next;
} Node;
typedef struct stack    
{
    Node *top; //相当于其数据域是一个结构体
    int count;
} Link_Stack;
//初始化
Link_Stack *Creat_stack(){
    Link_Stack *p;
    //p = new Link_Stack;
    p=(Link_Stack*)malloc(sizeof(Link_Stack));
    // if(p==NULL){
    //     printf("创建失败，即将退出程序");
    //     exit(0);
    // }
    p->count = 0;
    p->top = NULL;
    return p;
}
//头插
Link_Stack *Push_stack(Link_Stack *p, int elem){
    Node *temp;
    temp=(Node*)malloc(sizeof(Node));
    temp->data = elem;
    temp->next = p->top; 
    p->top = temp;
    p->count++;
    return p;
}
//出栈
Link_Stack *Pop_stack(Link_Stack *p){
    if (p->top == NULL){
        printf("错误：栈为空");
        return p;
    }else{
        Node *temp;
        temp = p->top;
        p->top = p->top->next;
        free(temp);  //记得释放空间
        //delete temp;
        p->count--;
        return p;
    }
}

了解了定义和基本操作，那它的操作的时间、空间复杂度是多少呢？
不管是顺序栈还是链式栈，在入栈和出栈过程中，只需要一两个临时变量存储空间，所以空间复杂度是0（1）。这里存储数据需要一个大小为n的数组，并不是说空间复杂度就是0（n）。因为，这n个空间是必须的，无法省掉。所以我们说空间复杂度的时候，是指除了原本的数据存储空间外，算法运行还需要额外的存储空间。
不管是顺序栈还是链式栈，入栈、出栈只涉及个别数据的操作，所以时间复杂度都是O（1）。

共享栈

题中告诉栈顶不对应数据，所以当左边top[1]移动到top[2]右边时，栈满，即top[1]-1=top[2]

此处栈顶指向元素

动态扩容的栈

刚才那个基于数组实现的栈，是一个固定大小的栈，也就是说，在初始化栈时需要事先指定栈的大小。当栈满之后，就无法再往栈里添加数据了。尽管链式栈的大小不受限，但要存储next指针，内存消耗相对较多。那我们如何基于数组实现一个可以支持动态扩容的栈呢？

typedef struct {  
    int *data;  //只需要改成*data就可以了
    int top;  
} Stack; 

或者在数组那一节，是如何来实现一个支持动态扩容的数组的？当数组空间不够时，我们就重新申请一块更大的内存，将原来数组中数据统统贝过去。这样就实现了一个支持动态扩容的数组
所以，如果要实现一个支持动态扩容的栈，我们只需要底层依赖一个支持动态扩容的数组就可以了。当栈满了之后，我们就申请一个更大的数组，将原来的数据搬移到新数组中。

实际上，支持动态扩容的顺序栈，我们平时开发中并不常用到。我讲这一块的目的，主要还是希望带你练习一下前面讲的复杂度分析方法。所以这一小节的重点是复杂度分析，你需要掌握的是分析方法。能够自己分析才算是真正掌握了。现在我就带你分析一下支持动态扩容的顺序栈的入栈、出栈操作的时间复杂度。
对于出栈操作来说，我们不会涉及内存的重新申请和数据的搬移，所以出栈的时间复杂度仍然是（1）。但是，对于入栈操作来说，情况就不一样了。当栈中有空闲空间时，入栈操作的时间复杂度为（1）。但当空间不够时，就需要重新申请内存和数据搬移，所以时间复杂度就变成了O（n）。
那平均情况下的时间复杂度又是多少呢？还记得我们在复杂度分析那一节中讲的还分析法吗？这个入栈操作的平均情况下的时间复杂度可以用摊还分析法来分析。
为了分析的方便，我们需要事先做一些假设和定义：
栈空间不够时，我们重新申请一个是原来大小两倍的数组
为了简化分析，假设只有入栈操作没有出栈操作；
定义不涉及内存搬移的入栈操作为simple-push操作，时间复杂度为O（1）。
如果当前栈大小为K，并且已满，当再有新的数据要入栈时，就需要重新申请2倍大小的内存，并且做K个数据的搬移操作，然后再入栈。但是，接下来的K-1次入栈操作，我们都不需要再重新申请内存和搬移数据，所以这K-1次入栈操作都只需要一个simple-push操作就可以完成。为了让你更加直观地理解这个过程，我画了一张图

你应该可以看出来，这K次入栈操作，总共涉及了K个数据的搬移，以及K次simple-push操作。将K个数据搬移均摊到K次入栈操作，那每个入栈操作只需要一个数据搬移和一个simple-push操作。以此类推，入栈操作的均摊时间复杂度就为O（1）。
通过这个例子的实战分析，也印证了前面讲到的，均摊时间复杂度一般都等于最好情况时间复杂度。因为大部分情况下，入栈的时间复杂度O都是（1），只有在个别时刻才会退化为O（n），所以把耗时多的入栈操作的时间均摊到其他入栈操作上，平均情况下的耗时就接近O（1）。

栈的应用

栈在函数调用中的应用

前面我讲的都比较偏理论，我们现在来看下，栈在软件工程中的实际应用。栈作为一个比较基础的数据结构，应用场景还是多的。其中，比较经典的一个应用场景就是函数调用栈。
我们知道，操作系统给每个线程分配了一块独立的内存空间，这块内存被组织成“栈”这种结构，用来存储函数调用时的临时变量。每进入一个函数，就会将临时变量作为一个栈入栈，当被调用函数执行完成，返回之后，将这个函数对应的栈出栈。为了让你更好地理解，我们一块来看下这段代码的执行过程。

int main() {
  int a = 1;
  int ret = 0;
  int res = 0;
  ret = add(3, 5);
  res = a + ret;
  printf("%d", res);
  reuturn 0;
}
int add(int x, int y) {
  int sum = 0;
  sum = x + y;
  return sum;
}

从代码中我们可以看出，main函数调用了add函数，获取计算结果，并且与临时变量a相加，最后打印res的值。为了让你清晰地看到这个过程对应的函数栈里出栈、入栈的操作，我画了一张图。图中显示的是，在执行到add函数时，函数调用栈的情况

栈在表达式求值中的应用

我们再来看栈的另一个常见的应用场景，编译器如何利用栈来实现表达式求值
我将算术表达式简化为只包含加减乘除四则运算，比如：34+13*9+44-12/3。
实际上，编译器就是通过两个栈来实现的。其中一个保存操作数的栈，另一个是保存运算符的栈。我们从左向右遍历表达式，当遇到数字，我们就直接压入操作数栈；当遇到运算符，就与运算符栈的栈顶元素进行比较。
如果比运算符栈顶元素的优先级高，就将当前运算符压入栈；如果比运算符栈顶元素的优先级低或者相同，从运算符栈中取栈顶运算符，从操作数栈的栈顶取2个操作数，然后进行计算，再把计算完的结果压入操作数栈，继续比较
我将3+5*8-6这个表达式的计算过程画成了一张图，你可以结合图来理解我刚讲的计算过程

栈在括号匹配中的应用

除了用栈来实现表达式求值，我们还可以借助栈来检查表达式中的括号是否匹配
我们同样简化一下背景。我们假设表达式中只包含三种括号，圆括号0、方括号和花括号，并且它们可以任意嵌套。那我现在给你一个包含三种括号的表达式字符串，如何检查它是否合法呢？
这里也可以用栈来解决。我们用栈来保存未匹配的左括号，从左到右依次扫描字符串。当扫描到左括号时，则将其压入栈中；当扫描到右括号时，从栈顶取出一个左括号。如果能够匹配，比如“（”跟“）”四配，则继续扫描剩下的字符串。如果扫描的过程中，遇到不能配对的右括
号，或者栈中没有数据，则说明为非法格式
当所有的括号都扫描完成之后，如果栈为空，则说明字符串为合法格式；否则，说明有未匹配的左括号，为非法格式。

如何实现浏览器的前进、后退功能？

其实，用两个栈就可以非常完美地解决这个问题。我们使用两个栈，X和Y，我们把首次浏览的页面依次压入栈X，当点击后退按钮时，再依次从栈中出栈，并将出栈的数据依次放入栈Y。当我们点击前进按钮时，我们依次从栈Y中取出数据，放入栈×中。当栈中没有数据时，那就说明没有页面可以继续后退浏览了。当栈Y中没有数据，那就说明没有页面可以点击前进按钮浏览了。比如你顺序查了a，b，c三个页面，我们就依次把a，b，c压入栈，当你通过页面b又跳转到新的页面d，页面c就无法再通过前进、后退按钮重复查看了，所以需要清空栈Y，d放入X

课后思考
我们在讲栈的应用时，讲到用函数调用栈来保存临时变量，为什么函数调用要用“栈”来保存临时变量呢？用其他数据结构不行吗？

答：因为函数调用的执行顺序符合后进者先出，先进者后出的特点。比如函数中的局部变量的生命周期的长短是 先定义的生命周期长，后定义的生命周期短；还有函数中调用函数也是这样，先开始执行的函数只有等到内部调用的其他函数执行完毕，该函数才能执行结束。正是由于函数调用的这些特点，根据数据结构是特定应用场景的抽象的原则，我们优先考虑栈结构。

我们都知道，JVM内存管理中有个“堆栈”的概念。栈内存用来存储局部变量和方法调用，堆内存用来存储Java中的对象。那JVM里面的“栈”跟我们这里说的“栈”是不是一回事呢？如果不是，那它为什么又叫作“栈”呢？

答：JVM里面的栈和我们这里说的是一回事，被称为方法栈。和前面函数调用的作用是一致的，用来存储方法中的局部变量。