<数据结构> 栈Stack

一.栈stack：先进后出 FILO

1.栈的主要功能是进行数据的存储和计算 栈是一种容器 是具有特殊限制的链表或数组

2.栈的存储方式：

①顺序存储：数组

空间固定 所以需要预先知道所需要开辟的空间有多大 数组难以进行扩容 所以导致可用空间是有限的

②链式存储：链表

栈可以理解为链表的头插头删 这种存储方式便于查找 又快又方便

3.栈的操作端为栈顶pTop 栈是没有栈底的概念的

4.栈的基本操作：

①栈的初始化init ②入栈压栈push ③出栈pop ④清空栈clear

⑤栈的销毁destroy ⑥获得栈顶元素 ⑦栈内总个数 ⑧栈是否为空

具体实现的时候 定义两个结构体 这样有利于栈的销毁的实现 具体代码如下：

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
    int num;
    struct node * pNext;
}MyStack;

typedef struct node2
{
    int count;
    MyStack* pTop;
}Stack;

void s_Init(Stack** ppStack)
{
    (*ppStack) = (Stack*)malloc(sizeof(Stack));
    (*ppStack) -> count = 0;
    (*ppStack) -> pTop = NULL;
}

void s_Push(Stack* pStack,int n)
{
    if(pStack == NULL) return ;

    MyStack* pMyStack = (MyStack*)malloc(sizeof(MyStack));
    pMyStack -> num = n;
    pMyStack -> pNext = pStack -> pTop;
    pStack -> pTop = pMyStack;

    pStack -> count ++;
}

int s_Pop(Stack* pStack)
{
    if(pStack == NULL || pStack -> count == 0) return -1;

    MyStack* pDel = pStack -> pTop;
    int n = pDel -> num;
    pStack -> pTop = pStack -> pTop -> pNext;
    free(pDel);
    pDel = NULL;

    pStack -> count --;
    return n;
}

void s_Clear(Stack* pStack)
{
    while(pStack -> count != 0)
    {
        s_Pop(pStack);
    }
}

void s_Destroy(Stack** pStack)
{
    s_Clear(*pStack);
    free(*pStack);
    *pStack = NULL;
}

MyStack* s_GetTop(Stack* pStack)
{
    return pStack -> pTop;
}

int s_GetCount(Stack* pStack)
{
    return pStack -> count;
}

int s_IsEmpty(Stack* pStack)
{
    return pStack -> count == 0? 1:0;
}

int main()
{
    Stack* pStack = NULL;
    s_Init(&pStack);

    s_Push(pStack,10);
    s_Push(pStack,11);
    s_Push(pStack,12);
    printf("Pop:%d
",s_Pop(pStack));
    printf("Pop:%d
",s_Pop(pStack));
    printf("Pop:%d
",s_Pop(pStack));
    printf("Count:%d",s_GetCount(pStack));

    return 0;
}

二.栈的应用

1.括号匹配问题：给一串如 ((())((()))) 这样的字符串 让我们判断括号数目是否匹配 就可以利用一个栈来解决这样的问题

解决：每当遇到“(”就入栈 遇到“)”就把栈中的一个“(”出栈

当栈中没有“(”可以出栈 或是 栈中最后剩余“(”没有括号与之进行匹配的时候 就说明这一串字符串括号是不匹配的 否则 括号匹配

2.递归就是一个入栈出栈的过程

PS：递归的适用场合：当处理大规模数据和处理小规模数据的方法一致时 可以使用递归

①著名的递归问题：斐波那契数列Fibonacci

F(1)=F(2)=1

F(n)=F(n-1)+F(n-2)

#include<stdio.h>

int Fib(int n)
{
    if(n == 1 || n == 2) return 1;
    else
    {
        return Fib(n-1) + Fib(n-2);
    }
}

int main()
{
    printf("%d
",Fib(10));
    return 0;
}

当递归调用的次数较少时 输出结果还可以正常的输出 但是当n为40 50甚至更大的时候 程序的运行就速度会没有那么快 可能会卡一段时间

所以不妨利用循环的方式来解决递归问题

②利用循环来解决Fibonacci问题

当n大于等于3的时候 可以把F(n)理解为c 把F(n-1)理解为b 那么F(n-2)即为a

利用循环 从3开始 不断的去更新a b和c这三个变量的值 去计算F(n)的值

实现代码如下：

#include<stdio.h>

int Fib(int n)
{
    if(n == 1 || n == 2) return 1;
    else if(n >= 3)
    {
        int a = 1;
        int b = 1;
        int c = 0;
        int i = 3;
        for(i;i<=n;i++)
        {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
}

int main()
{
    printf("%d
",Fib(10));
    return 0;
}

③递归和循环的比较

递归：利用递归来解决实际问题 会很慢

因为递归就是函数调用的过程 函数调用就是一个压栈出栈的问题 所以无论是时间还是空间都消耗巨大

但是递归的优点就是代码量少 实现起来只要逻辑理解了 就很简单

循环：循环相比递归利用的时间和空间就会小一些 但是劣势也很明显 就是代码量比较多

其实 利用栈和循环是可以替代递归的 数组也可以 只不过数组的话 需要提前预知开辟空间大小

④解决一个问题的最好方法 可能永远是数学问题吧 斐波那契数列的解决方法也有数学方法 这里就不说了 我自己理解起来都费劲

3.逆波兰表示法：四则运算

这里主要是 中缀表达式和后缀表达式之间的相互转换 先介绍一下规则

①中缀转后缀规则：借助辅助栈

遇到数字或者字符直接打印

遇到符号 将符号与栈顶元素进行优先级比较：如果当前元素优先级高 则直接入栈 如果当前元素优先级低 则将栈内元素依次出栈

直到比当前元素优先级低为止 将当前元素入栈

如果遇到“(” 无条件入栈 如果遇到“)” 将栈内元素依次出栈 直到找到“(”为止

②后缀转中缀规则：借助辅助栈

遇到数字或字符直接入栈

遇到符号 将栈顶元素的下一个和栈顶元素构成表达式

③中缀转后缀的简便做法：

把所有的表达式括起来 然后把符号拿到所在的括号的外面并且去掉所有括号 即为后缀表达式

例如：(6+4)*9-8/2 → (((6+4)*9)-(8/2)) → 64+9*82/-