03栈 stack

最新推荐文章于 2023-09-07 20:31:28 发布
最新推荐文章于 2023-09-07 20:31:28 发布
阅读量159 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 栈 stack 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Caijingxiang/article/details/119102794
版权

栈 stack

  • 一个先入后出的有序列表。

在这里插入图片描述

数组实现栈：

package msp.cai.stack;

/*
 * 数组实现栈
 */
public class ArrayStackDemo {
    public static void main(String[] args) {
        ArrayStack stack = new ArrayStack(5);
        System.out.println("== 入栈 ==");
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.showStack();
        System.out.println("== 出栈 ==");
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
    }
}

class ArrayStack {
    int maxSize;    // 最大长度
    int top = -1;    // 栈顶
    int[] arr;  // 存放数据

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[this.maxSize];
    }

    // 判断栈满
    public boolean isFull() {
        return top==(maxSize-1);
    }

    // 判断栈空
    public boolean isEmpty() {
        return top==-1;
    }

    // 入栈
    public void push(int data) {
        if (isFull())
            return;
        arr[++top] = data;
    }

    // 出栈
    public int pop() {
        if (isEmpty())
            return -1;
        return arr[top--];
    }

    // 打印栈
    public void showStack() {
        if (isEmpty()) {
            System.out.println("栈为空~");
        } else {
            System.out.println("栈中数据为：");
            for (int i = 0; i <= top; i++) {
                System.out.printf("%d\t",arr[i]);
            }
            System.out.println();
        }
    }
}

栈实现计算器：

思路：

  • 使用两个栈，munStack（数字栈） operaStack（符号栈）
  1. 通过一个index（索引），遍历表达式字符串
  2. 如果是数字，直接入栈
  3. 如果是字符：
    1. 若栈为空，直接push
    2. 若栈不为空：
      1. 若当前符号优先级大于栈顶符号的优先级，push
      2. 否则，从数字栈pop两个数，从符号栈pop运算符，将运算结果push到数字栈，最后将当前符号push到符号栈。
    3. 当表达式扫描完毕，顺序计算。即pop两个数与一个运算符，将计算结果push到数字栈。
package msp.cai.stack;

/*
 * 栈实现表达式计算
 */
public class ArrayStackDemo01 {
    public static void main(String[] args) {
        // 创建数字栈与符号栈
        numStack n_stack = new numStack(100);
        operaStack o_stack = new operaStack(50);

        String exp = "1+1*8+2*6";
        for (int i = 0; i < exp.length(); i++) {
            char item = exp.charAt(i);
            // 符号
            if (item=='+' || item=='-' || item=='*' || item=='/') {
                if (o_stack.isEmpty())
                    o_stack.push(item);
                else {
                    char top_opera = o_stack.getTop();
                    if ((item=='*' || item=='/') && (top_opera=='+' || top_opera=='-'))
                        o_stack.push(item);
                    else {
                        int num1 = n_stack.pop();
                        int num2 = n_stack.pop();
                        char ope = o_stack.pop();
                        n_stack.push(calculation(num1,num2,ope));
                        o_stack.push(item);
                    }
                }
            }
            // 是数字，直接入栈
            else {
                int num = item - '0';
                n_stack.push(num);
            }
        }
        while (!o_stack.isEmpty()) {
            int num1 = n_stack.pop();
            int num2 = n_stack.pop();
            char ope = o_stack.pop();
            n_stack.push(calculation(num1,num2,ope));
        }
        System.out.println("计算结果为: " + n_stack.pop());
    }

    // 计算方法
    public static int calculation(int nim1, int num2, char ope) {
        int result = 0;
        switch (ope){
            case '+':
                result = num2 + nim1;
                break;
            case '-':
                result = num2 - nim1;
                break;
            case '*':
                result = num2 * nim1;
                break;
            case '/':
                result = num2 / nim1;
                break;
        }
        return result;
    }
}

// 数字栈
class numStack {
    private int maxSize;
    private int top;
    private int[] arr;

    public numStack(int maxSize) {
        this.maxSize = maxSize;
        top = -1;
        arr = new int[this.maxSize];
    }

    // 判断栈满
    public boolean isFull() {
        return top==(maxSize-1);
    }

    // 判断栈空
    public boolean isEmpty() {
        return top==-1;
    }

    // 入栈
    public void push(int data) {
        if (isFull())
            return;
        arr[++top] = data;
    }

    // 出栈
    public int pop() {
        if (isEmpty())
            return -1;
        return arr[top--];
    }
}
// 符号栈
class operaStack {
    private int maxSize;
    private int top;
    private char[] arr;

    public operaStack(int maxSize) {
        this.maxSize = maxSize;
        top = -1;
        arr = new char[this.maxSize];
    }

    // 判断栈满
    public boolean isFull() {
        return top==(maxSize-1);
    }

    // 判断栈空
    public boolean isEmpty() {
        return top==-1;
    }

    // 入栈
    public void push(char data) {
        if (isFull())
            return;
        arr[++top] = data;
    }

    // 出栈
    public char pop() {
        if (isEmpty())
            return '0';
        return arr[top--];
    }

    // 获取栈顶元素
    public char getTop() {
        if (isEmpty()) {
            return '0';
        }
        return arr[top];
    }
}

前缀 中缀 后缀 表达式：

  • 前缀

    • 从右至左扫描表达式，遇到数字入栈，遇到运算符时，弹出两个数字进行计算，将结果入栈。
    • 中缀：（3+4）*5 -6 --> 前缀：- * + 3 4 5 6

  • 中缀

    • 我们熟知的，但对于计算机来说不好操作。

  • 后缀表达式

    • 逆波兰表达式，与前缀相似，运算符位于数字后面。
    • 从左至右扫描表达式，遇到数字入栈，遇到运算符时，弹出两个数字进行计算，将结果入栈。
    • 中缀：（3+4） * 5 - 6 --> 后缀：3 4 + 5 * 6 -

中缀转后缀：

中缀：1 + ((2+3) * 4) - 5

  1. 初始化两个栈：符号栈s1和中间结果栈s2；
  2. 从左至右扫描中缀表达式；
  3. 遇到操作数，push到s2；
  4. 遇到运算符时，
    1. 若s1为空，或者栈顶为“(”时，直接将此运算符push到s1；
    2. 否则若优先级高于栈顶运算符，直接将此运算符push到s1；
    3. 否则，将s1栈顶运算符pop，然后push到s2，返回4.1，重新判断。
  5. 遇到括号时，
    1. 左括号“(”，直接push到s1；
    2. 右括号“)”，依次pop s1中的符号，push到s2中，直到遇到左括号，此时就相当于去掉了一对括号。
  6. 重复步骤2-5，直至扫描完中最表达式；
  7. 将s1中剩余运算符依次pop并push到s2
  8. s2出栈结果的逆序即为后缀表达式。
package msp.cai.stack;

import java.util.ArrayList;
import java.util.Stack;

/*
 *  使用栈实现计算表达式：
 *    1. 获取表达式字符串
 *    2. 中缀 -->  后缀
 *    3. 计算结果
 */
public class BolanCalculator {
    public static void main(String[] args) {
        // 中缀表达式
        String midStr = "1 + ( ( 2 + 3 ) * 4 ) - 5";
        System.out.println("中缀表达式为： " + midStr);
        // 将中缀转后缀 "1 2 3 + 4 * + 5 - "
        String rearStr = mid2rear(midStr);
        System.out.println("后缀表达式为： " + rearStr);
        String[] rearStrArr = rearStr.split(" ");
        // 入栈
        Stack<String> stack = new Stack<String>();
        for (String s : rearStrArr) {
            if (!isNotANumber(s))
                stack.push(s);
            else {
                int num1 = Integer.parseInt(stack.pop());
                int num2 = Integer.parseInt(stack.pop());
                switch (s) {
                    case "+":
                        stack.push(String.valueOf(num2+num1));
                        break;
                    case "-":
                        stack.push(String.valueOf(num2-num1));
                        break;
                    case "*":
                        stack.push(String.valueOf(num2*num1));
                        break;
                    case "/":
                        stack.push(String.valueOf(num2/num1));
                        break;
                }
            }
        }
        System.out.println("计算结果为： " + stack.pop());
    }

    // 中缀表达式转后缀表达式
    public static String mid2rear(String midStr) {
        // 1. 初始化两个栈
        Stack<String> s1 = new Stack<String>();     // 符号栈
        Stack<String> s2 = new Stack<String>();     // 中间结果栈
        String[] str = midStr.split(" ");
        // 2. 从左至右依次扫描
        for (String s : str) {
            // 3. 遇到操作数，push
            if (!isNotANumber(s))
                s2.push(s);
            // 4. 遇到运算符时
            else if (!isBracket(s)){
                while (true) {
                    // 4.1 若s1为空，或栈顶为“(”时，直接入栈
                    if (s1.isEmpty() || s1.peek().equals("(")) {
                        s1.push(s);
                        break;
                    }
                    // 4.2 当前字符优先级高于栈顶字符，直接入栈
                    if (getPriority(s) > getPriority(s1.peek())) {
                        s1.push(s);
                        break;
                    }
                    // 4.3 否则将s1栈顶运算符pop，push到s2，返回4.1
                    String pop = s1.pop();
                    s2.push(pop);
                }
            }
            // 5. 遇到括号时
            else {
                // 5.1 遇到“(”，直接push
                if (s.equals("("))
                    s1.push(s);
                // 5.2 依次pop s1中的符号，push到s2中，直到遇到左括号
                else {
                    String pop;
                    while (!(pop=s1.pop()).equals("("))
                        s2.push(pop);
                }
            }
        }
        // 6. 将s1中剩余运算符依次pop并push到s2
        while (!s1.isEmpty())
            s2.push(s1.pop());
        // 7. 后缀表达式即为s2出栈的逆序
        ArrayList<String> rearArr = new ArrayList<String>();
        while (!s2.isEmpty()) {
            rearArr.add(s2.pop());
        }
        StringBuilder rearStr = new StringBuilder();
        for (int i = rearArr.size()-1; i >= 0; i--) {
            rearStr.append(rearArr.get(i)).append(" ");
        }
        return rearStr.toString();
    }

    // 判断字符串是否为操作数
    public static boolean isNotANumber(String str) {
        return str.equals("+") || str.equals("-") || str.equals("*")
                || str.equals("/") || str.equals("(") || str.equals(")");
    }

    // 判断字符串是否是括号
    public static boolean isBracket(String str) {
        return str.equals("(") || str.equals(")");
    }

    // 获取字符的优先级
    public static int getPriority(String str) {
        if (str.equals("*") || str.equals("/"))
            return 1;
        else if (str.equals("+") || str.equals("-"))
            return 0;
        else
            return -1;
    }
}
伟大的兔兔
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
表达式转换(PTA)
woteicaile的博客
12-15 3431
算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。日常使用的算术表达式是采用中缀表示法，即二元运算符位于两个运算数中间。请设计程序将中缀表达式转换为后缀表达式。 输入格式: 输入在一行中给出不含空格的中缀表达式，可包含+、-、*、\以及左右括号()，表达式不超过20个字符。 输出格式: 在一行中输出转换后的后缀表达式，要求不同对象（运算数、运算符号）之间以空格分隔，但结尾不得有多余空格。 输入样例: 2+3*(7-4)+8/4 输出样例: 2 3 7 4 - * + 8 4 / + 我的代码是格式错误，
C++栈stack算法 最全面
最新发布
07-23
栈stack算法：算法训练营 P68~74 题目类型 ：栈stack问题 P69~74 原题解析 ：见算法训练营 P74~74 */ #include using namespace std; int main() { cout栈算法"; cout初始值为 http://www.acm.org"<<'\n'; cout...
中缀表达式转换为后缀表达式（oj题库）
12-21
中缀表达式转换为后缀表达式（oj题库） 中缀表达式转换为后缀表达式（oj题库） 题目描述 中缀表达式是一个通用的算术或逻辑公式表示方法，操作符是以中缀形式处于操作数的中间（例：3 + 4），中缀表达式是人们常用的算术表示方法。后缀表达式不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则，如：(2 + 1) * 3 ， 即2 1 + 3 *。利用栈结构，将中缀表达式转换为后缀表达式。(测试数据元素为单个字符) 输入 中缀表达式 输出 后缀表达式 代码如下 #include #include #include using namesp
栈应用—中缀表达式和后缀表达式转换（原理和练习题目详解）
橘露源的博客
06-26 4720
中缀表达式转后缀表达式 规则：从左到右遍历中缀表达式的每个数字和符号，如果是数字直接写出（即成为后缀表达式的一部分）；若是符号，则判断与栈顶符号的优先级，若是右括号或低于栈顶符号优先级（当是右括号时候，注意输出的只是左括号以上的符号）（乘除优先于加减），那么栈顶元素依次出栈并输出，同时将当前符号进栈，一直打到最终输出为止。 后缀表达式转中缀表达式 从左到右遍历表达式的每个数字和符号，遇到数字...
【二叉树练习题】中缀表达式转换成后缀表达式
Bitdancing的专栏
02-04 314
题解 先使用中缀表达式构建二叉树 中序遍历，运算符一定为父结点 后续遍历的结果： abcd/+e*-
中缀表达式转换成后缀表达式
m0_74478846的博客
12-04 1452
中缀表达式转换成后缀表达式
Stack-栈实例
10-23
栈是一种特殊的线性数据结构，遵循“后进先出”（LIFO）的原则。在计算机科学中，栈常被用于解决各种问题，如表达式求值、递归、内存管理等。下面我们将深入探讨栈的基本概念、静态栈与链表栈的实现方式，以及它们在...
JS栈stack类的实现与使用方法示例
10-17
在JS中实现栈（Stack）数据结构及使用方法是JavaScript数据结构与算法知识的一部分，它涉及对栈这种数据结构特性的理解和实现。栈是一种特殊的列表，其插入和删除操作仅限在一端进行，使得这一端被称为栈顶，而另...
JavaScript实现栈结构Stack过程详解
10-15
JavaScript中的栈结构（Stack）是一种线性数据结构，它的特点是后进先出（LIFO）。在实际编程中，栈常用于函数调用栈、递归等场景。在JavaScript中实现栈，可以通过数组来模拟栈的基本操作，如push、pop、peek、...
Stack_栈_
10-03
在编程语言中，许多内置数据结构如Python的list、C++的std::stack等都提供了对栈的支持。 在实际应用中，栈常常用于解决以下问题： 1. 括号匹配：通过维护一个字符栈，遇到左括号就入栈，遇到右括号时检查栈顶元素...
中缀表达式转后缀表达式
10-01
利用之前的栈的顺序存储和栈的链式存储，写了一个就近匹配和中缀表达式转后缀表达式，
中缀转后缀表达式_案例分析
qq_39112175的博客
07-01 280
中缀转后缀表达式案例分析
[数据结构考前必看]中缀表达式转化成后缀表达式_例题超多+分步骤讲解+带你手算
夏2同学的博客
11-30 8186
中缀、后缀表达式定义 中缀表达式又称波兰式，有利于人们阅读与表达。 后缀表达式又称逆波兰式，有利于机器进行运算。 例题1： 中缀表达式：(a+b+c*d) /e 首先让我们来看一下运算符对应的优先级，显然括号里的**“乘法”**的优先级最高，所以先得出cd*，让我们把cd*记为q，括号里的表达式即可转化成a+b+q。 然后括号里还剩下两个加法，两者的优先级相同，依次读取，a+b首先转化成a...
高深面试题 （中缀表达式转为后缀表达式）
坚持就是胜利的博客
01-12 1171
1.表达式a+b*c-(d+e)/f的后缀表达式为？ 扫描的方式从左到右 依次进行扫描 参数放到参数栈中 符号 放到符号 栈中 扫描的次数 扫描到的值 参数栈 符号栈 解释 第一次 a a 第一次扫描到的是a 直接放到参数栈中 第二次 + a + 第二次扫描到的是加号直接放到符号栈中 第三次 b ba + 第三次扫描到的是b依次放到参数栈中 第四次 * ba ...
中缀表达式转后缀表达式（逆波兰式）
qq_33300585的博客
09-07 2034
中缀表达式转后缀表达式（逆波兰式）
中缀表达式转后缀表达式，并计算结果（java）
LX__Mr的博客
09-21 970
后缀表达式的计算机求值过程：（== 逆波兰表达式==） 从左至右扫描表达式，遇到数字时，就将数字压入栈中，遇到运算符时，就弹出栈顶的两个数字，用运算符对它们做相应的计算（次顶元素和栈顶元素），并将结果入栈；重复上述过程，直到表达式的最右端，最后运算得到的值就是表达式的结果 例：(3+4)×5-6对应的后缀表达式为 3 4 + 5 × 6，针对后缀表达式求值步骤如下： ①从左至右扫描，将3和4压入栈中； ②遇到运算符 + ，因此弹出 4 和 3（4 为栈顶元素， 3 为次顶元素），计算 3 + 4 的值，得到
【Weiss】【第03章】练习3.20：中缀表达式转后缀表达式
weixin_30598225的博客
03-20 135
【练习3.20】 a.编写一个程序将中缀表达式转换为后缀表达式，该中缀表达式含括号及四则运算。 b.把幂操作符添加到你的指令系统中去。 c.编写一个程序将后缀表达式转化为中缀表达式。 Answer: 花了好大力气把a，b就放一起写好了，终于知道为啥说编译原理难了，就这么简单的句法分析也好坑爹。 c真的不打算写了，如果以后要学编译原理的话再继续吧。 （一）、首先是核心思路，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值