【轻松学数据结构】绝对是对栈讲解最详细的，没有之一（附动图，源码，六千字详细总结）

最新推荐文章于 2024-06-19 18:08:01 发布
最新推荐文章于 2024-06-19 18:08:01 发布
阅读量234 收藏
点赞数
分类专栏： 面试 学习路线 阿里巴巴 文章标签： android 前端 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54852350/article/details/124790285
版权
面试 同时被 3 个专栏收录
56 篇文章 0 订阅
订阅专栏
阿里巴巴
46 篇文章 0 订阅
订阅专栏
学习路线
45 篇文章 0 订阅
订阅专栏

??本专栏将使用Java语言实现所有数据结构（如有需要，也可以用C++实现），从基础开始，循序渐进，也请大家多多支持。数据结构虽然难，但只要肯坚持，一定能学好，希望大家都能够从中有所收获。
??专栏地址:数据结构专栏
??本专栏的所有代码都将更新在Gitee上，项目地址：项目地址
??相关数据结构演示软件:链接地址
??在线演示地址：https://visualgo.net/zh https://algorithm-visualizer.org/

文章目录

1 栈的基本概念

线性表是具有相同数据类型的n（n≥0）个数据元素的有限 序列，其中n为表长，当n = 0时线 性表是一个空表。若用L命名线性表，则其一般表示为

L = （ a 1 , a 2 , . . . , a i , a i + 1 , . . . , a n ） L=（a_1,a_2,…,a_i,a_{i+1},…,a_n） L=（a1,a2,…,ai,ai+1,…,an）

而栈（Stack）是只允许在一端进行插入或删除操作的线性表:

image-20220505110433168

相关定义:

栈是一种特殊的线性结构，先进后出，只能在一段进行操作，我们把允许插入和删除的一端称为栈顶，另一端称为栈底。

  • 不含任何数据元素的栈称为空栈。
  • 栈的插入操作叫做进栈，也叫做压栈、入栈
  • 栈的删除操作，叫做出栈，也叫做弹栈。
  • 我们一般吧运行操作的一端叫做top（栈顶），并用一个变量进行标示

入栈和出栈的动图演示如下图所示:

在这里插入图片描述

由此可以看出栈最底部的元素是最先入栈的，而栈顶元素是最后入栈的，但是出栈时则倒了过来，栈顶元素先出栈，栈底元素最后出栈。所以，栈中元素遵循「后进先出」（last-in-first-out，LIFO）的规律。

在实际应用中通常只会对栈执行以下两种操作:

向栈中添加元素，此过程被称为"进栈"（入栈或压栈）

栈中提取出指定元素，此过程被称为"出栈"（或弹栈）

栈的具体实现

栈是一种 “特殊” 的线性存储结构，因此栈的具体实现有以下两种方式：

顺序栈：采用顺序存储结构可以模拟栈存储数据的特点，从而实现栈存储结构；

链栈：采用链式存储结构实现栈结构；

下面分别介绍两种栈的实现方式。

2 栈的顺序存储实现

顺序栈的定义及内存结构如下图所示:

image-20220505134323765

2.1 顺序栈的初始化

顺序栈的初始化只需要将栈顶指针top的值赋值为-1即可:

image-20220505134508504

2.2 顺序栈的进栈操作

顺序栈的进栈操作只需要将栈顶加1，将新元素入栈即可，动图如下:

顺序表入栈gif

具体代码如下:

public void push(int x){
    if (top == MaxSize-1){ //栈满，报错
        return;
    }
    top += 1;               //栈顶加1
    data[top] = x;          //新元素入栈
}

2.3 顺序栈的出栈操作

顺序栈的出栈只需要将栈顶减1:

顺序表出栈

代码如下:

public int pop(int x){
    if (top == -1){ //栈空，报错
        return -1;
    }
    int topValue = data[top];
    top -= 1;               //栈顶减1
    return topValue;
}

3 栈的链式存储实现

顺序栈的定义及内存结构如下图所示:

image-20220505141721516

3.1 链栈的进栈操作

链栈的进栈和出栈，对应的是头结点的变化，如果是入栈，则头结点变为新插入的节点，如果是入栈，则头结点变为头结点的后一个结点，如下图所示:

链栈入栈

代码如下:

//push
    public void push(T data){
        LinkedNode newNode = new LinkedNode(data);
        newNode.next = first;
        first = newNode;
    }

3.2 链栈的出栈操作

//pop
    public T pop(){
        if (first == null){
            System.out.println("链表为空");
            return null;
        }
        T front =  first.iData;
        first = first.next;
        return front;
    }

完整代码如下

//链栈

//结点
class LinkedNode<T>{
    public T iData;         //数据域
    public LinkedNode<T> next;    //指向下一个结点

    public LinkedNode(T iData) {
        this.iData = iData;
        this.next = null;
    }

    public LinkedNode(T iData, LinkedNode<T> next) {
        this.iData = iData;
        this.next = next;
    }

    //输出用
    @Override
    public String toString() {
        return "LinkedNode{" +
                "iData=" + iData +
                ", next=" + next +
                '}';
    }
}
//链栈
class LinkedStack<T> {
    public LinkedNode<T> first; //链表的第一个结点

    //构造函数
    public void LinkList() {
        first = null;
    }

    //判断链栈是否为空
    public boolean isEmpty() {
        return first == null;
    }

    //push
    public void push(T data){
        LinkedNode newNode = new LinkedNode(data);
        newNode.next = first;
        first = newNode;
    }

    //pop
    public T pop(){
        if (first == null){
            System.out.println("链表为空");
            return null;
        }
        T front =  first.iData;
        first = first.next;
        return front;
    }

}


public class _002LinkStackTest {

    public static void main(String[] args) {
        LinkedStack<Integer> integerLinkedNode = new LinkedStack<Integer>();

        integerLinkedNode.push(1);
        integerLinkedNode.push(2);
        integerLinkedNode.push(3);

        while(!integerLinkedNode.isEmpty()){
            System.out.println(integerLinkedNode.pop());
        }


    }
}

4 栈在括号匹配中的应用

所谓括号校验匹配其实质是对多种类型括号正确配对的校验（包括：()、[]、{}）即([])或者[()]为正确的表达式，如果出现交叉则匹配失败，如[(])或([())则为不正确格式，如下图所示，

image-20220505150929471

从上图可以发现：

1:每出现一个有括号，就消耗一个左括号

2:最后出现的左括号最先被匹配

所以可以用栈的特性来解决该问题,算法演示如下：

[图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-puahFYHD-1651852044567)(https://gitee.com/xzj-cgw/Data-Structure-and-Algorithm-study-notes/raw/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/imgs.assets/括号匹配-16517362825942.gif)]

代码如下:

public static boolean bracketCheck(String str){
    LinkedStack<Character> S = new LinkedStack<Character>(); //初始化一个栈
    for(int i=0;i<str.length();i++){
        //如果扫描到左括号，则入栈
        if(str.charAt(i) == '(' || str.charAt(i) == '[' || str.charAt(i) == '{' ){
            S.push(str.charAt(i));
        }else{
            //扫描到右括号，且当前栈空
            if(S.isEmpty()){
                return false;
            }
            //栈顶元素出栈
            char topElem = S.pop();
            //判断是否匹配
            if(str.charAt(i) == ')' && topElem != '('){
                return false;
            }
            if(str.charAt(i) == ']' && topElem != '['){
                return false;
            }
            if(str.charAt(i) == '}' && topElem != '{'){
                return false;
            }
        }
    }
    //检索完全部括号后，栈空说明匹配成功
    return S.isEmpty();
}

完整代码如下:

//链栈

import java.util.Scanner;

//结点
class LinkedNode<T>{
    public T iData;         //数据域
    public LinkedNode<T> next;    //指向下一个结点

    public LinkedNode(T iData) {
        this.iData = iData;
        this.next = null;
    }

    public LinkedNode(T iData, LinkedNode<T> next) {
        this.iData = iData;
        this.next = next;
    }

    //输出用
    @Override
    public String toString() {
        return "LinkedNode{" +
                "iData=" + iData +
                ", next=" + next +
                '}';
    }
}
//链栈
class LinkedStack<T> {
    public LinkedNode<T> first; //链表的第一个结点

    //构造函数
    public void LinkList() {
        first = null;
    }

    //判断链栈是否为空
    public boolean isEmpty() {
        return first == null;
    }

    //push
    public void push(T data){
        LinkedNode newNode = new LinkedNode(data);
        newNode.next = first;
        first = newNode;
    }

    //pop
    public T pop(){
        if (first == null){
            System.out.println("链表为空");
            return null;
        }
        T front =  first.iData;
        first = first.next;
        return front;
    }



}


public class _002LinkStackTest {
    public static boolean bracketCheck(String str){
        LinkedStack<Character> S = new LinkedStack<Character>(); //初始化一个栈
        for(int i=0;i<str.length();i++){
            //如果扫描到左括号，则入栈
            if(str.charAt(i) == '(' || str.charAt(i) == '[' || str.charAt(i) == '{' ){
                S.push(str.charAt(i));
            }else{
                //扫描到右括号，且当前栈空
                if(S.isEmpty()){
                    return false;
                }
                //栈顶元素出栈
                char topElem = S.pop();
                //判断是否匹配
                if(str.charAt(i) == ')' && topElem != '('){
                    return false;
                }
                if(str.charAt(i) == ']' && topElem != '['){
                    return false;
                }
                if(str.charAt(i) == '}' && topElem != '{'){
                    return false;
                }
            }
        }
        //检索完全部括号后，栈空说明匹配成功
        return S.isEmpty();
    }

    public static void main(String[] args) {
//        LinkedStack<Integer> integerLinkedNode = new LinkedStack<Integer>();
//
//        integerLinkedNode.push(1);
//        integerLinkedNode.push(2);
//        integerLinkedNode.push(3);
//
//        while(!integerLinkedNode.isEmpty()){
//            System.out.println(integerLinkedNode.pop());
//        }
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();  //测试案例:[(())[]]
        System.out.println(bracketCheck(str));


    }
}

代码的运行结果如下:

image-20220505162428571

5 栈在表达式求值中的应用

下图是我们所熟悉的算术表达式:

image-20220505170003096

该算法表达式由三部分组成:操作数、运算符、界限符（界限符指括号，反映了计算的先后顺序）。忽然有一天，一位来自波兰的数学家有了一个这样的一个灵感:能否可以不用界限符也能无 歧义地表达运算顺序？然后就出现了波兰表达式(前缀表达式)和逆波兰表达式(后缀表达式)。接下来介绍一下中缀表达式、后缀表达式以及前缀表达式分别是什么东西:

image-20220505170449103

5.1 中缀表达式

中缀表达式就是我们生活中常见的表达式，如下图所示：

image-20220505170844699

5.2 后缀表达式

后缀表达式，又称逆波兰式，不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则），非常方便计算机的计算。

后缀表达式计算的具体过程如下：

1从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算，并将结果入栈

2重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果

计算后缀表达式的动态流程如下,以1+2-3*2的后缀表达式为例:

[图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fVU9358L-1651852044580)(https://gitee.com/xzj-cgw/Data-Structure-and-Algorithm-study-notes/raw/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/imgs.assets/计算后缀表达式.gif)]

另一个一个案例：

后缀表达式为“2 3 + 4 × 5 -”计算过程如下：
1从左至右扫描，将 2 和 3 压入堆栈；
2 遇到 + 运算符，因此弹出 3 和 2（ 3 为栈顶元素，2 为次顶元素），计算出 3+2 的值，得 5，再将 5 入栈；
3 将 4 入栈；
4接下来是 × 运算符，因此弹出 4 和 5，计算出 4 × 5 = 20，将 20 入栈；
5将 5 入栈；
6最后是-运算符，计算出 20-5 的值，即 15，由此得出最终结果

5.3 中缀表达式转后缀表达式过程

中缀转后缀的手算方法（考试时候会用到，这里不做具体讨论，主要讨论算法实现的步骤）：

1 确定中缀表达式中各个运算符的运算顺序

2 选择下一个运算符，按照「左操作数 右操作数 运算符」的方式组合成一个新的操作数

3 如果还有运算符没被处理，就继续 2

用代码实现中缀表达式转后缀表达式算法实现的步骤如下：
1初始化两个栈：运算符栈s1和储存中间结果的栈s2；
2 从左至右扫描中缀表达式；
3 遇到操作数时，将其压s2；
4 遇到运算符时，比较其与 s1 栈顶运算符的优先级：
1)：如果 s1 为空，或栈顶运算符为左括号“(”，则直接将此运算符压入s1；
2)：否则，若优先级比栈顶运算符的高，也将运算符压入 s1;
3)：否则，说明优先级小于等于栈顶运算符的优先级，将 s1 栈顶的运算符弹出并压入到 s2 中，再次转到4.1与s1中新的栈顶运算符相比较；
5 遇到括号时：
1)：如果是左括号“(”，则直接压入 s1；
2)：如果是右括号“)”，则依次弹出 s1 栈顶的运算符，并压入 s2 ，直到遇到左括号为止，此时将这一对括号丢弃；
6 重复步骤（2）至（5），直到表达式的最右边；
7 将 s1 中剩余的运算符依次弹出并压入 s2；
8 依次弹出 s2 中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

例如，将中缀表达式“1+((2+3)×4)-5”转换为后缀表达式的过程如下：

在这里插入图片描述

表格的形式如下所示:

扫描到的元素

s2(栈底->栈顶)

s1 (栈底->栈顶)

说明

1

1

空

数字，直接入栈

1

s1为空，运算符直接入栈

(

1

+ (

左括号，直接入栈

(

1

+ ( (

同上

2

1 2

+ ( (

数字

1 2

+ ( ( +

s1栈顶为左括号，运算符直接入栈

3

1 2 3

+ ( ( +

数字

)

1 2 3 +

+ (

右括号，弹出运算符直至遇到左括号

×

1 2 3 +

+ ( ×

s1栈顶为左括号，运算符直接入栈

4

1 2 3 + 4

+ ( ×

数字

)

1 2 3 + 4 ×

右括号，弹出运算符直至遇到左括号

–

1 2 3 + 4 × +

–

-与+优先级相同，因此弹出+，再压入-

5

1 2 3 + 4 × + 5

–

数字

到达最右端

1 2 3 + 4 × + 5 –

空

s1中剩余的运算符

代码演示如下:

//中缀转后缀
public static String midTranstoBack(String str){
    LinkedStack<Character> s1 = new LinkedStack<Character>(); //栈s1,用于存储符号
    LinkedStack<Character> s2 = new LinkedStack<Character>(); //栈s2，用于存储数字
    HashMap<Character, Integer> characterHashMap = new HashMap<Character, Integer>();//用于存放优先级，数字越小，优先级越小
    characterHashMap.put('+',0);
    characterHashMap.put('-',0);
    characterHashMap.put('*',1);
    characterHashMap.put('/',1);
    characterHashMap.put('(',2);
    characterHashMap.put(')',2);
    for(int i=0;i<str.length();i++){
        char ch = str.charAt(i);
        //如果是数字,直接放到s2
        if(ch >= '0' && ch <= '9'){
            s2.push(ch);
        }
        else if(ch=='('){ //如果是左括号,直接压入s1
            s1.push(ch);
        }
        else if(ch==')'){ //如果是右括号,则依次弹出 s1 栈顶的运算符，并压入 s2 ，直到遇到左括号为止，此时将这一对括号丢弃
            char tmp = s1.pop();
            while(tmp != '('){
                s2.push(tmp);
                tmp = s1.pop();
            }
        }
        else {//否则为运算符
            {
                // 如果 s1 为空，或栈顶运算符为左括号“(”，则直接将此运算符压入s1
                while (true){
                    if(s1.isEmpty() || s1.top() == '('){
                        s1.push(ch);
                        break;
                    }
                    //get是获取key对应的值,若优先级比栈顶运算符的高，将运算符压入s1
                    else if(characterHashMap.get(ch) > characterHashMap.get(s1.top())){
                        s1.push(ch);
                        break;
                    }
                    //若优先级小于等于栈顶运算符的高，将运算符压入s1
                    else {
                        s2.push(s1.pop());
                    }
                }
            }
        }
    }
    //将 s1 中剩余的运算符依次弹出并压入 s2
    while(!s1.isEmpty()){
        s2.push(s1.pop());
    }
    StringBuffer sb = new StringBuffer();
    //结果的逆序即为中缀表达式对应的后缀表达式
    while (!s2.isEmpty()){
        sb.insert(0,s2.pop());
    }
    return sb.toString();
}

关键部分如下图所示:

image-20220506130244428

这里的栈采用的是链式栈，没有使用系统的ArrayList，完整代码如下所示:

//链栈

// symbol match

import java.util.HashMap;
import java.util.Scanner;

//结点
class LinkedNode<T>{
    public T iData;         //数据域
    public LinkedNode<T> next;    //指向下一个结点

    public LinkedNode(T iData) {
        this.iData = iData;
        this.next = null;
    }

    public LinkedNode(T iData, LinkedNode<T> next) {
        this.iData = iData;
        this.next = next;
    }

    //输出用
    @Override
    public String toString() {
        return "LinkedNode{" +
                "iData=" + iData +
                ", next=" + next +
                '}';
    }
}
//链栈
class LinkedStack<T> {
    public LinkedNode<T> first; //链表的第一个结点

    //构造函数
    public void LinkList() {
        first = null;
    }

    //判断链栈是否为空
    public boolean isEmpty() {
        return first == null;
    }

    //push
    public void push(T data){
        LinkedNode newNode = new LinkedNode(data);
        newNode.next = first;
        first = newNode;
    }

    //pop
    public T pop(){
        if (first == null){
            System.out.println("链表为空");
            return null;
        }
        T front =  first.iData;
        first = first.next;
        return front;
    }

    //top 获得栈顶元素
    public T top(){
        if(first == null){
            return null;
        }
        return first.iData;
    }

}


public class _002LinkStackTest {
    
    //中缀转后缀
    public static String midTranstoBack(String str){
        LinkedStack<Character> s1 = new LinkedStack<Character>(); //栈s1,用于存储符号
        LinkedStack<Character> s2 = new LinkedStack<Character>(); //栈s2，用于存储数字
        HashMap<Character, Integer> characterHashMap = new HashMap<Character, Integer>();//用于存放优先级，数字越小，优先级越小
        characterHashMap.put('+',0);
        characterHashMap.put('-',0);
        characterHashMap.put('*',1);
        characterHashMap.put('/',1);
        characterHashMap.put('(',2);
        characterHashMap.put(')',2);
        for(int i=0;i<str.length();i++){
            char ch = str.charAt(i);
            //如果是数字,直接放到s2
            if(ch >= '0' && ch <= '9'){
                s2.push(ch);
            }
            else if(ch=='('){ //如果是左括号,直接压入s1
                s1.push(ch);
            }
            else if(ch==')'){ //如果是右括号,则依次弹出 s1 栈顶的运算符，并压入 s2 ，直到遇到左括号为止，此时将这一对括号丢弃
                char tmp = s1.pop();
                while(tmp != '('){
                    s2.push(tmp);
                    tmp = s1.pop();
                }
            }
            else {//否则为运算符
                {
                    // 如果 s1 为空，或栈顶运算符为左括号“(”，则直接将此运算符压入s1
                    while (true){
                        if(s1.isEmpty() || s1.top() == '('){
                            s1.push(ch);
                            break;
                        }
                        //get是获取key对应的值,若优先级比栈顶运算符的高，将运算符压入s1
                        else if(characterHashMap.get(ch) > characterHashMap.get(s1.top())){
                            s1.push(ch);
                            break;
                        }
                        //若优先级小于等于栈顶运算符的高，将运算符压入s1
                        else {
                            s2.push(s1.pop());
                        }
                    }
                }
            }
        }
        //将 s1 中剩余的运算符依次弹出并压入 s2
        while(!s1.isEmpty()){
            s2.push(s1.pop());
        }
        StringBuffer sb = new StringBuffer();
        //结果的逆序即为中缀表达式对应的后缀表达式
        while (!s2.isEmpty()){
            sb.insert(0,s2.pop());
        }
        return sb.toString();
    }

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();  //测试案例1+((2+3)*4)-5
        System.out.println(midTranstoBack(str));

    }
}

5.4 栈实现后缀表达式的计算

用栈实现后缀表达式的计算流程如下：

1从左往右扫描下一个元素，直到处理完所有元素

2若扫描到操作数则压入栈，并回到1；否则执行3

3若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到1

计算后缀表达式的动态流程如下,以1+2-3*2的后缀表达式为例:

[链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hXd7cNlz-1651852044589)(https://gitee.com/xzj-cgw/Data-Structure-and-Algorithm-study-notes/raw/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/imgs.assets/计算后缀表达式.gif)]

对应的代码如下:

public static int calcValue(String str){
    LinkedStack<Integer> s1 = new LinkedStack<Integer>();
    for(int i=0;i<str.length();i++){
        char ch = str.charAt(i);
        if(ch>='0' && ch<='9'){//如果是数字,入栈
            s1.push(ch - '0');
        }
        else {//否则为运算符
            int num1 = s1.pop();
            int num2 = s1.pop();
            //计算完后压栈
            if('+' == ch){
                s1.push(num2+num1);
            }
            else if('-' == ch){
                s1.push(num2-num1);
            }
            else if('*' == ch){
                s1.push(num2*num1);
            }
            else if('/' == ch){
                s1.push(num2/num1);
            }
        }
    }
    //栈顶元素即为计算的结果
    return s1.top();
}

测试结果如下:

image-20220506131921292

完整代码如下:

//链栈

// symbol match

import java.util.HashMap;
import java.util.Scanner;

//结点
class LinkedNode<T>{
    public T iData;         //数据域
    public LinkedNode<T> next;    //指向下一个结点

    public LinkedNode(T iData) {
        this.iData = iData;
        this.next = null;
    }

    public LinkedNode(T iData, LinkedNode<T> next) {
        this.iData = iData;
        this.next = next;
    }

    //输出用
    @Override
    public String toString() {
        return "LinkedNode{" +
                "iData=" + iData +
                ", next=" + next +
                '}';
    }
}
//链栈
class LinkedStack<T> {
    public LinkedNode<T> first; //链表的第一个结点

    //构造函数
    public void LinkList() {
        first = null;
    }

    //判断链栈是否为空
    public boolean isEmpty() {
        return first == null;
    }

    //push
    public void push(T data){
        LinkedNode newNode = new LinkedNode(data);
        newNode.next = first;
        first = newNode;
    }

    //pop
    public T pop(){
        if (first == null){
            System.out.println("链表为空");
            return null;
        }
        T front =  first.iData;
        first = first.next;
        return front;
    }

    //top 获得栈顶元素
    public T top(){
        if(first == null){
            return null;
        }
        return first.iData;
    }

}


public class _002LinkStackTest {
    // 括号匹配
    public static boolean bracketCheck(String str){
        LinkedStack<Character> S = new LinkedStack<Character>(); //初始化一个栈
        for(int i=0;i<str.length();i++){
            //如果扫描到左括号，则入栈
            if(str.charAt(i) == '(' || str.charAt(i) == '[' || str.charAt(i) == '{' ){
                S.push(str.charAt(i));
            }else{
                //扫描到右括号，且当前栈空
                if(S.isEmpty()){
                    return false;
                }
                //栈顶元素出栈
                char topElem = S.pop();
                //判断是否匹配
                if(str.charAt(i) == ')' && topElem != '('){
                    return false;
                }
                if(str.charAt(i) == ']' && topElem != '['){
                    return false;
                }
                if(str.charAt(i) == '}' && topElem != '{'){
                    return false;
                }
            }
        }
        //检索完全部括号后，栈空说明匹配成功
        return S.isEmpty();
    }

    //中缀转后缀
    public static String midTranstoBack(String str){
        LinkedStack<Character> s1 = new LinkedStack<Character>(); //栈s1,用于存储符号
        LinkedStack<Character> s2 = new LinkedStack<Character>(); //栈s2，用于存储数字
        HashMap<Character, Integer> characterHashMap = new HashMap<Character, Integer>();//用于存放优先级，数字越小，优先级越小
        characterHashMap.put('+',0);
        characterHashMap.put('-',0);
        characterHashMap.put('*',1);
        characterHashMap.put('/',1);
        characterHashMap.put('(',2);
        characterHashMap.put(')',2);
        for(int i=0;i<str.length();i++){
            char ch = str.charAt(i);
            //如果是数字,直接放到s2
            if(ch >= '0' && ch <= '9'){
                s2.push(ch);
            }
            else if(ch=='('){ //如果是左括号,直接压入s1
                s1.push(ch);
            }
            else if(ch==')'){ //如果是右括号,则依次弹出 s1 栈顶的运算符，并压入 s2 ，直到遇到左括号为止，此时将这一对括号丢弃
                char tmp = s1.pop();
                while(tmp != '('){
                    s2.push(tmp);
                    tmp = s1.pop();
                }
            }
            else {//否则为运算符
                {
                    // 如果 s1 为空，或栈顶运算符为左括号“(”，则直接将此运算符压入s1
                    while (true){
                        if(s1.isEmpty() || s1.top() == '('){
                            s1.push(ch);
                            break;
                        }
                        //get是获取key对应的值,若优先级比栈顶运算符的高，将运算符压入s1
                        else if(characterHashMap.get(ch) > characterHashMap.get(s1.top())){
                            s1.push(ch);
                            break;
                        }
                        //若优先级小于等于栈顶运算符的高，将运算符压入s1
                        else {
                            s2.push(s1.pop());
                        }
                    }
                }
            }
        }
        //将 s1 中剩余的运算符依次弹出并压入 s2
        while(!s1.isEmpty()){
            s2.push(s1.pop());
        }
        StringBuffer sb = new StringBuffer();
        //结果的逆序即为中缀表达式对应的后缀表达式
        while (!s2.isEmpty()){
            sb.insert(0,s2.pop());
        }
        return sb.toString();
    }

    public static int calcValue(String str){
        LinkedStack<Integer> s1 = new LinkedStack<Integer>();
        for(int i=0;i<str.length();i++){
            char ch = str.charAt(i);
            if(ch>='0' && ch<='9'){//如果是数字,入栈
                s1.push(ch - '0');
            }
            else {//否则为运算符
                int num1 = s1.pop();
                int num2 = s1.pop();
                if('+' == ch){
                    s1.push(num2+num1);
                }
                else if('-' == ch){
                    s1.push(num2-num1);
                }
                else if('*' == ch){
                    s1.push(num2*num1);
                }
                else if('/' == ch){
                    s1.push(num2/num1);
                }
            }
        }
        return s1.top();
    }

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();  //测试案例1+((2+3)*4)-5,1+2-3*2
        String backStr = midTranstoBack(str);
        System.out.println(backStr);
        System.out.println(calcValue(backStr));


    }
}

6 栈和递归的关系

什么是递归，举个例子：“为了理解递归，必须首先理解递归”。对于初次接触递归的同学，递归可能很难理解，在其最简单的形式中，递归函数是一个可以调用自己的函数，且每一个递归函数都有两个条件：一个是终止条件（终止调用的条件）另一个是递归条件（自己调用自己）。

递归在底层的调用中，会将所有函数调用都先压入调用栈，等到出现终止条件了再从调用栈中依次进行弹出，这也就是所谓的回调（回溯）。

当递归函数没完没了的运行时，将会使得递归函数里面调用栈不断的扩大，但程序中可使用的调用栈空间有限，该程序捡回因栈溢出而终止，出现经典的Stack Overflow错误。

6.1 什么时候使用递归？

6.1.1 数学定义是递归的

例如阶乘:

/*阶乘:Fact(n)
(1) 若n=0, 则返回1;
(2) 若n > 1, 则返回n*Fact(n-1);
例子:
*/
 long Fact(int n){
 if(n=0) return -1;
 else return n * Fact(n-1);
}

/*(斐波拉契数列:Fib(n)
(1) 若n=1或n=2, 则返回1;
(2) 若n > 2, 则返回Fib(n-1) + Fib(n-2);
例子:*/
long Fib(int n){ 
 if(n == 1 || n == 2) return 1;
 else return Fib(n-1)+Fib(n-2);
}

对于类似这种的复杂问题,若能分解成几个简单且解法类似的子问题来求解,则称为递归求解。

补充:什么时候使用分治法

(1)能将一个大问题转变为一个小问题,而新问题和原问题解法类似或相同,不同的仅仅是处理的对象,并且这些处理更小且变化是有规律的;(可拆解)

(2)可以通过上述转化而使得问题简单化;(简化问题)

(3)必须有一个明确的递归出口(递归边界);(终止递归的条件)

总结:在递归算法中,如果当递归结束条件成立,只执行Return操作时,分治法求解递归问题算法一般形式可以简化为:

void p(参数表,形参 ){
if(递归结束的条件) Return 结果; //递归边界
else p(参数); //递归的步棸
}
6.1.2 数据结构是递归的

其数据结构本身有递归的特性;

例如:对于链表,其节点LNode的定义有数据域data和指针域dext组成,而指针域next是一种指向LNode类型的指针,即LNode的定义中又用到了其自身,所以链表是一种递归的数据结构;

void TraverseList(LinkList p){
	//递归的终止条件
	if(p == null) return;
	//递归步棸
	else{
		//输出当前节点的数据域
		System.out.println(p->data); 
        	//移动指针,输出下一个节点的数据域
        	TraverseList(p->next);
	}
}
6.1.3 问题的解法是递归的

有一类问题,虽然问题本身并没有明显的递归结果,但是采用递归求解比迭代求解更简单,例如:Hanoi塔问题,八皇问题,迷宫问题等。

6.2 递归过程与递归函数栈

一个递归函数,在函数的执行过程中,需要多次进行自我调用,那么思考一下,此时的递归函数是如何执行的

在了解递归函数是如何执行之前,先了解一下任意两个函数之间的调用是如何进行的在高级语言的程序中，调用函数和被调用函数之间的连接与信息的交换都是通过栈来进行的。通常,当在一个函数的运行期间调用另一个函数时,在运行被调用函数之前,系统要做三件事:

1 将所有的实参,返回地址等信息调用传递给被调用函数保存;

2 为被调用函数的局部变量分配存储空间;

3 将控制权转移到被调用函数入口;

而从被调用函数返回到调用函数之前,系统同样要做三件事情:

1 保存被调用函数的计算结果;

2 释放被调用函数的数据区;

3依照被调用函数保存的返回地址将控制权移动到调用函数;

当多个函数构成嵌套调用时,按照"先调用后返回"的原则,上述函数之间的信息传递和控制传递都必须通过"栈"来实现,即系统程序整个运行时的所需要的数据空间都安排在一个栈中,每当调用一个函数时,就在它的栈顶分配一个存储区,每当这个函数退出时,就释放它的存储区,则当前运行的函数的数据区必须在栈顶。

下图是调用栈的一个案例，先被调用的函数在底部，后调用的函数在上部:

image-20220506211808215

m0_54852350
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】三万字图文讲解带你手撕八大排序(附源码)
StackFrame
12-31 2105
排序概念梳理、八大排序图文讲解 + 代码实现，时空复杂度及稳定性分析，测试框架（附源码）
打造最漂亮的串口通讯调试助手 基于C# WPF .net4开发 附源码带详细注释
06-27
WPF界面全部用XAML语言手打，基本都是Grid布局，VS很强大，编程很舒服便捷，源码有很详细的注释。 * 学C#和WPF编的第一个软件，整个编程过程，通过百度不断学习 * 作者是做硬件的，只为学习做简单的上位机程序，...
【轻松学数据结构】动图剖析数据结构中的线性结构（六千字超详细教程，附源码）
Learning_xzj的博客
05-04 793
🌱本专栏将使用Java语言实现所有数据结构（如有需要，也可以用C++实现）。本专栏将会从基础开始，循序渐进，也请大家多多支持。数据结构虽然难，但只要肯坚持，一定能学好，希望大家都能够从中获益。 📫专栏地址:数据结构专栏 📫本专栏的所有代码都将更新在Gitee上，项目地址：项目地址 📫相关数据结构演示软件:链接地址 📫在线演示地址：https://visualgo.net/zh https://algorithm-visualizer.org/ 文章目录线性表的介绍线性表的定义顺序表的基本操作顺序表的插.
【数据结构】八大排序(超详解+附动图+源码)
Edward_Asia的博客
11-21 8万+
前言 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 生活中各种地方都需要用到排序，所以学好排序算法是非常重要的。 排序分为 内部排序 和 外部排序。 内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。 这部分主要是内部排序。排序讲解都以升序为例。 常见的排序算法： // 排序实现的接口 // 插入排序 void InsertSort(int* arr..
【数据结构复习之路】栈和队列（本站最全最详细讲解）& 严蔚敏版
m0_74215326的博客
10-12 1319
万字详解，主打基础，看完保证让你收获满满ε٩(๑> ₃
【每天一道算法题】栈的应用：将中缀表达式转为后缀表达式以及后缀表达式求值(附动图，源码，讲解最详细，没有之一)
Learning_xzj的博客
05-06 2793
🌱本专栏将会从基础开始，循序渐进，每天刷一道算法题，也请大家多多支持。数据结构虽然难，但只要肯坚持，一定能学好，希望大家都能够从中获益。 📫专栏地址: 🍇每日一道算法题专栏 🍉数据结构专栏 📫本专栏的所有代码都将更新在Gitee上，项目地址：项目地址 📫相关数据结构演示软件:链接地址 📫数据结构在线演示地址：https://visualgo.net/zh https://algorithm-visualizer.org/ 准备好了吗 Let’s go! 1 栈在表达式.
数据结构之栈的讲解（源代码+图解+习题）
2302_76941579的博客
10-25 668
/用顺序表模拟栈int top;}ST;
【超全汇总】学习数据结构与算法，计算机基础知识，看这篇就够了
热门推荐
帅地
01-18 10万+
由于文章有点多，并且发的文章也不是一个系列一个系列发的，不过我的文章大部分都是围绕着 数据结构 + 算法 + 计算机网络 + 操作系统 + Linux + 数据库 这几个方面发的，为了方便大家阅读，我整理了一波。不过公众号可以说是不支持修改文章，因为我决定每两三个月就整理一次，会非常详细着按照类别整理出来哦，并且也给出了目录哦。大家记得多看看哦，好多文章都是面试中常问滴 文章目录一、经验/经历/所...
【轻松学数据结构】硬核手撕数据结构中的顺序表、单(双)链表、环形链表、静态链表（六千字超详细教程，附源码）
Learning_xzj的博客
05-05 633
🌱本专栏将使用Java语言实现所有数据结构（如有需要，也可以用C++实现）。本专栏将会从基础开始，循序渐进，也请大家多多支持。数据结构虽然难，但只要肯坚持，一定能学好，希望大家都能够从中获益。 📫专栏地址:数据结构专栏 📫本专栏的所有代码都将更新在Gitee上，项目地址：项目地址 📫相关数据结构演示软件:链接地址 📫在线演示地址：https://visualgo.net/zh https://algorithm-visualizer.org/ 文章目录线性表的介绍线性表的定义顺序表的基本操作顺序表的插.
学算法先学数据结构？是否是无稽之谈？
英雄哪里出来
03-02 2万+
头发没了
任性动图轻松做闪字、动图、动画.rar
05-25
任性动图V9.1--轻松做闪字、动图、动画.rar
Java版数据结构与算法视频教程(44集版)，附源码资料
02-11
Java版数据结构与算法视频教程(44集版)，附源码资料 目录找不到 讲的很详细
【原创】C#导出数据到EXCEL方法谈（附实例源码和超级无敌详细讲解）
11-08
以上4中方法都可以实现导出EXCEL，方法1为最基础的方法，意思就是效率可能不是太高，当遇到数据量过大时所要付出的时间也是巨大的，后面3种方法都是第一种的衍生，在第一种方法效率低下的基础上改进的，这里主要就是...
数据结构与算法全集（C源代码+详细注释）
11-27
全集内容结构如下： ├─图 │ ├─关键路径（有向无环图及其应用2） │ │ 1.txt │ │ ALGraph.cpp │ │ ALGraph.h │ │ CriticalPath.cpp │ │ CriticalPath.h │ │ InfoType.cpp │ │ InfoType.h │ │ ...
【Android 11】AOSP Settings添加屏幕旋转按钮
xuanyulevel6的博客
06-13 510
这里是客户要求添加按钮以实现屏幕旋转。这里的值可以是0，1，2，3 的任意一个。我这里没有陀螺仪，所以只需要这个命令就够了。更多的可以参考但是这有个缺陷，就是开机的动画不能随着设置好的屏幕方向旋转。
Android本地Gradle Plugin的创建以及使用
龙叔的专栏
06-12 371
2.新建一个module 取名叫buildSrc(注意，一定要叫这个名字，而且在setting.gradle中不要include这个Moudle，gradle会自动引入)有些Gradle插件，不想放到云端，本来也只是小功能而已，还放到云端，每次修改和发布都很麻烦，这种需求的插件放到本地还是合适的。使用就是在build.gradle中，正常使用插件。1.直接放到build.gradle。
RK3588 Android13去掉底部导航栏和修改壁纸图片
suifen_的博客
06-17 141
【代码】RK3588 Android13去掉底部导航栏和修改壁纸图片。
全志 Android 11：实现响应全局按键
最新发布
上周的博客
06-19 180
最近实现热键想功能，简单总结了下全志平台Android 11 的响应全局热键的方法。
【数据结构】八大排序(超详解+附动图+源码)_风继续吹tt的博客-csdn博客_排序
09-17
7、堆排序：构建一个最大堆，将堆顶元素与末尾元素交换，然后重新调整堆结构，重复这个过程直到所有元素排序完毕。 8、计数排序：通过统计元素的频次来排序，适用于元素范围不大的情况。首先统计每个元素的出现次数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值