第五章、栈（数组模拟栈、链栈、逆波兰表达式、中缀表达式、后缀表达式）

最新推荐文章于 2024-10-08 21:30:52 发布
最新推荐文章于 2024-10-08 21:30:52 发布
阅读量109 收藏
点赞数
分类专栏： JAVA算法与数据结构 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42403145/article/details/126192603
版权

文章目录

栈

数组模拟栈

栈

public class ArrayStack {
    private int maxSize;
    private int[] stack;
    private int top = -1;

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

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

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

    //入栈
    public void push(int value){
        if (isFull()){
            System.out.println("栈满，入栈失败");
            return;
        }

        top++;
        stack[top] = value;
    }

    //出栈
    public int pop(){
        if (isEmpty())
            throw new RuntimeException("栈空，出栈失败");

        int value = stack[top];
        top--;
        return value;
    }

    //遍历栈（从栈顶开始）
    public void show(){
        if (isEmpty()){
            System.out.println("栈空");
            return;
        }

        for (int i = top; i >= 0; i--) {
            System.out.println("stack[" + i + "] = " + stack[i]);
        }
    }
}

测试

public class test {
    public static void main(String[] args) {
        String key = "";
        ArrayStack stack = new ArrayStack(4);
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("show：展示栈中元素");
            System.out.println("push：入栈");
            System.out.println("pop：出栈");
            System.out.println("exit：退出");
            System.out.println("请输入你的选择：");
            key = sc.next();

            switch (key){
                case "show":
                    stack.show();
                    break;
                case "push":
                    System.out.println("请输入一个数：");
                    int value = sc.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try {
                        int n = stack.pop();
                        System.out.println("出栈的元素为：" + n);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    sc.close();
                    System.out.println("退出成功");
                    return;
                default:
                    break;
            }
        }
    }
}

链栈

节点类

public class HeroNode {
    private int no;
    private HeroNode next = null;

    public HeroNode(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public HeroNode getNext() {
        return next;
    }

    public void setNext(HeroNode next) {
        this.next = next;
    }
}

链栈

public class LinkedStack {
    private HeroNode head = new HeroNode(0);

    //入栈
    public void push(int value){
        HeroNode temp = new HeroNode(value);
        temp.setNext(head.getNext());
        head.setNext(temp);
    }

    //出栈
    public int pop(){
        if (head.getNext() == null)
            throw new RuntimeException("栈为空，出栈失败");

        int value = head.getNext().getNo();
        head.setNext(head.getNext().getNext());
        return value;
    }

    //遍历
    public void show(){
        if (head.getNext() == null){
            System.out.println("栈为空");
            return;
        }

        HeroNode temp = head.getNext();
        int n = 0;
        while (temp != null){
            n++;
            System.out.println("stack[" + n + "] = " + temp.getNo());
            temp = temp.getNext();
        }
    }
}

测试

public class LinkedStackTest {
    public static void main(String[] args) {
        String key = "";
        LinkedStack stack = new LinkedStack();
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("show：展示栈中元素");
            System.out.println("push：入栈");
            System.out.println("pop：出栈");
            System.out.println("exit：退出");
            System.out.println("请输入你的选择：");
            key = sc.next();

            switch (key){
                case "show":
                    stack.show();
                    break;
                case "push":
                    System.out.println("请输入一个数：");
                    int value = sc.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try {
                        int n = stack.pop();
                        System.out.println("出栈的元素为：" + n);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    sc.close();
                    System.out.println("退出成功");
                    return;
                default:
                    break;
            }
        }
    }
}

逆波兰表达式计算器

栈

public class ArrayStack2 {
    private int maxSize;
    private int[] stack;
    private int top = -1;

    public ArrayStack2(int maxSize){
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

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

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

    //入栈
    public void push(int value){
        if (isFull()){
            System.out.println("栈满，入栈失败");
            return;
        }

        top++;
        stack[top] = value;
    }

    //出栈
    public int pop(){
        if (isEmpty())
            throw new RuntimeException("栈空，出栈失败");

        int value = stack[top];
        top--;
        return value;
    }

    //遍历栈（从栈顶开始）
    public void show(){
        if (isEmpty()){
            System.out.println("栈空");
            return;
        }

        for (int i = top; i >= 0; i--) {
            System.out.println("stack[" + i + "] = " + stack[i]);
        }
    }

    //显示栈顶元素
    public int peek(){
        if (isEmpty())
            throw new RuntimeException("栈为空");

        return stack[top];
    }

    //判断优先级
    public int priority(int num){
        if (num == '+' || num == '-')
            return 0;
        else if (num == '*' || num == '/')
            return 1;
        else
            return -1;
    }

    //判断是否是运算符
    public boolean isOper(int num){
        return num == '+' || num == '-' || num == '*' || num == '/';
    }

    //计算结果
    public int cal(int num1, int num2, int oper){
        switch (oper){
            case '+':
                return num1 + num2;
            case '-':
                return num2 - num1;
            case '*':
                return num1 * num2;
            case '/':
                return num2 / num1;
            default:
                break;
        }
        return 0;
    }
}

计算器

public class Calculator {
    public static void main(String[] args) {
        String key = "70*2*2-5+1-5+3-3";

        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);

        int Index = 0;
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';
        String keepNum = "";

        while (Index < key.length()) {
            ch = key.substring(Index, Index + 1).charAt(0);
            if (operStack.isOper(ch)) {
                if (operStack.isEmpty()) {
                    //如果运算符栈为空，则运算符直接入栈
                    operStack.push(ch);
                } else {
                    //如果运算符栈不空，则将运算符栈中优先级大于此运算符的运算符全部弹出，并在数栈中弹出两个数参与运算，并将结果入数栈
                    while (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        numStack.push(res);

                    //若所有运算符都被弹出栈则直接进栈
                        if (operStack.isEmpty())
                            break;
                    }
                    operStack.push(ch);
                }
            } else {
                keepNum += ch;  //  700)    70+2)   7)
                //可能有多位数参与运算，所以如果是数，继续扫描到后面第一个运算符前面的数字字符当成一个整体入栈
                while (true){
                    if (Index == key.length() - 1)
                        break;
                    Index++;
                    ch = key.substring(Index, Index + 1).charAt(0);
                    if (!operStack.isOper(ch))
                        keepNum += ch;
                    else {
                        Index--;
                        break;
                    }
                }
                numStack.push(Integer.parseInt(keepNum));
                keepNum = "";
            }
            Index++;
        }

        while (!operStack.isEmpty()){
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);
            numStack.push(res);
        }

        System.out.println("计算结果为：" + numStack.pop());
    }
}

中缀表达式的计算和后缀表达式的计算

判断优先级

public class Operation {
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;

    public static int priority(String key){
        int res = 0;
        switch (key) {
            case "+":
                res = ADD;
                break;
            case "-":
                res = SUB;
                break;
            case "*":
                res = MUL;
                break;
            case "/":
                res = DIV;
                break;
            default:
                System.out.println("运算符有误");
                break;
        }
        return res;
    }
}

主类

/**
 * 完成计算后缀表达式的值
 * 完成将中缀表达式转化成后缀表达式，并求值
 */

public class PolandNotation {
    public static void main(String[] args) {
        //String suffixExpression = "30 4 + 5 * 6 -";
//        String suffixExpression = "4 5 * 8 - 60 + 8 2 / +";
//
//        List<String> list = tolist(suffixExpression);
//        System.out.println("list[] = " + list);
//
//        int res = calculator(list);
//        System.out.println("计算结果为：" + res);
        String infixExpression = "1+((2+3)*4)-5";
        List<String> infixList = toInfixExpressionList(infixExpression);
        System.out.println("中缀表达式为：" + infixList);

        List<String> suffixList = parsesuffixExpressionList(infixList);
        System.out.println("后缀表达式为：" + suffixList);

        System.out.println("计算结果为：" + calculator(suffixList));


    }

    //将中缀表达式转化成后缀表达式
    public static List<String> parsesuffixExpressionList(List<String> infixList) {
        Stack<String> s1 = new Stack<>();
        List<String> s2 = new ArrayList<>();

        for (String temp : infixList) {
            if (temp.matches("\\d+")) {
                s2.add(temp);
            } else if (temp.equals("(")) {
                s1.push(temp);
            } else if (temp.equals(")")) {
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();
            } else {
                while (!s1.isEmpty() && !s1.peek().equals("(")) {
                    if (Operation.priority(temp) > Operation.priority(s1.peek())) {
                        break;
                    } else {
                        s2.add(s1.pop());
                    }
                }
                s1.push(temp);
            }
        }

        while (!s1.isEmpty()){
            s2.add(s1.pop());
        }
        return s2;
    }


    //将字符串中缀表达式放到List中存储
    public static List<String> toInfixExpressionList(String infixExpression) {
        List<String> list = new ArrayList<>();
        int i = 0;
        char c;
        String string;

        while (i < infixExpression.length()) {
            c = infixExpression.charAt(i);
            if (c < 48 || c > 57) {
                list.add("" + c);
                i++;
            } else {
                string = "";
                while (i < infixExpression.length() && (c = infixExpression.charAt(i)) >= 48
                        && (c = infixExpression.charAt(i)) <= 57) {
                    string += c;
                    i++;
                }
                list.add(string);
            }
        }

        return list;
    }


    //将逆波兰表达式放到ArrayList里去
    public static List<String> tolist(String suffixExpression) {
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<>();

        for (String temp : split) {
            list.add(temp);
        }

        return list;
    }

    //计算逆波兰表达式
    public static int calculator(List<String> list) {
        Stack<String> stack = new Stack<>();
        for (String temp : list) {
            if (temp.matches("\\d+")) {
                stack.push(temp);
            } else {
                int num1 = Integer.parseInt(stack.pop());
                int num2 = Integer.parseInt(stack.pop());
                int res = 0;
                if (temp.equals("+")) {
                    res = num2 + num1;
                } else if (temp.equals("-")) {
                    res = num2 - num1;
                } else if (temp.equals("*")) {
                    res = num2 * num1;
                } else if (temp.equals("/")) {
                    res = num2 / num1;
                } else {
                    throw new RuntimeException("运算符有误");
                }
                //System.out.println(res);
                stack.push("" + res);
            }
        }

        return Integer.parseInt(stack.pop());
    }


}
数二150种子选手
关注
专栏目录
波兰式、逆波兰式与表达式求值
CSDN
12-30 10万+
波兰式、逆波兰式与表达式求值 　　《数据结构》中关于栈的解释经常会涉及到逆波兰式，波兰式，中缀式表达式的求值问题。但是，十分惭愧，整个大一阶段， 数据结构的课程没有上够5节，没有意识要学习，吃亏真的很大，只能现在恶补了。废话不说了，进入正题。 1. 中缀表达式 人类最熟悉的一种表达式1+2，(1+2)*3，3+4*2+4等等都是中缀表示法。对于人们来说，也是最直观的一种...
学习笔记-中缀表达式转逆波兰表达式(后缀表达式)
12-21
中缀表达式转后缀表达式实现计算器(支持括号以及小数点不支持空白符) 思路图: 这里的s2栈我直接改为ArrayList因为最后是栈的结果的逆序，用ArrayList即可。ok上代码: public class PolandNotation { public static...
《数据结构》：中缀表达式转后缀表达式 + 后缀表达式的计算
热门推荐
Amentos的博客
10-07 8万+
《数据结构》实验报告：中缀/后缀/前缀表达式基本概念 + 前缀转后缀 + 后缀表达式的计算 + 完整算法实现
中缀表达式转逆波兰表达式（后缀表达式）
Jacks丶的博客
09-28 5863
总结波兰表达式与逆波兰表达式，用代码实现中缀表达式转逆波兰表达式。
【算法】中缀表达式转成后缀表达式（逆波兰表达式）再计算得出结果
qq_27198345的博客
08-16 1183
逆波兰表达式
C语言栈的运用：中缀表达式转后缀表达式（逆波兰表达式）
CaptainUniverse_的博客
04-04 1229
C语言栈的运用：中缀表达式转后缀表达式（逆波兰表达式）
[数据结构]栈实现中缀表达式转换为逆波兰表达式并计算
weixin_43717520的博客
04-13 1071
这是一个草稿 准备写逆波兰计算器。写之前我要先去看看代码 因为我忘了代码了。
使用栈实现表达式的计算前缀、中缀、后缀表达式（逆波兰表达式）
共勉
04-28 2526
前缀表达式的计算机求值 从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算(栈项元素和次顶元素)，并将结果入栈;重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。 例如: (3+4)X5-6 对应的前缀表达式就是 - X + 3 4 5 6 ,针对前缀表达式求值步骤如下:
栈的链式结构以及中缀表达式转后缀表达式（逆波兰式）C语言实现
zcg_741454897的博客
11-13 1988
栈的数据结构就不多说了，后进先出，只有一个出口。最典型的应用就是中缀表达式转后缀表达式，因为计算机不能识别人类所认知的中缀表达式，逆波兰式多用于编译器实现、自然语言处理这些常用的领域。下面介绍中缀转后缀的具体过程。 比如1+3*（2+5）转化成后缀表达式是：1325+*+，转化算法为： 1、对于数字，直接输出 2、对于符号： 左括号：进栈，不管栈中是否有元素 运算符：若此时栈为...
C++逆波兰表达式求值——将后缀表达式转化为中缀表达式进行计算
qq_41884662的博客
03-20 3108
逆波兰表达式，也叫做后缀表达式。如图： 我们平时见到的运算表达式是中缀表达式，即 “操作数① 运算符② 操作数③” 的顺序，运算符在两个操作数中间。 但是后缀表达式是 “操作数① 操作数③ 运算符②” 的顺序，运算符在两个操作数之后。 各种表达式没有本质区别，他们其实是同一个语法树，只是遍历方式不同而得到的不同式子；是一个事物的一体多面，只不过是从不同角度观察罢了。 中缀表达式是其对应的语法树的中序遍历； 后缀表达式是其对应的语法树的后序遍历； 前缀表达式是其对应的语法树的前序遍历； 下图中左边是中缀表达
中缀表达式求后缀表达式的快速方法（波兰表达式求逆波兰表达式）
小清华的小哥哥
11-07 2057
中缀表达式求后缀表达式的快速方法（波兰表达式求逆波兰表达式） 表达式求值是栈的重要应用之一，中缀表达式（也称波兰表达式）顺应了人类的思维方式，因此我们可以很直观地判断运算的优先级并进行笔算求值。但在计算机中处理后缀表达式则更方便，因此在计算机中往往需要将中缀表达式转换成后缀表达再式进行求值运算。 学习数据结构的时候，常用的中缀表达式转后缀表达式的方法是构造一颗二叉树，然后对二叉树进行先序，中序和后续遍历就可以分别得到对应的前缀，中缀，后缀表达式，这种方法和思想当然是必须掌握的，并且要能用代码的方式实现。 然
后缀表达式/波兰表达式/链式栈的应用
11-05
后缀表达式，又称波兰表达式，是一种在计算科学中广泛使用的表示数学运算的方法，它在计算机算法设计和数据结构领域具有重要的应用价值。后缀表达式的最大特点是运算符位于操作数之后，这种方式使得表达式的解析更为...
Python实现处理逆波兰表达式示例
12-31
逆波兰表达式又叫做后缀表达式。在通常的表达式中，二元运算符总是置于与之相关的两个运算对象之间，这种表示法也称为中缀表示。波兰逻辑学家J.Lukasiewicz于1929年提出了另一种表示表达式的方法，按此方法，每一...
JDK1.0主要特性
FoolRabbit的专栏
10-06 393
JDK1.0主要特性。
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1156
2024最新Java面试题，针对一些小厂，中厂
SpringBoot集成MinIO
QB哥欢迎您
10-05 1250
MinIO：它是一个对象存储服务。类似于云服务器厂商提供的OSS服务。在项目中经常有大量的图片等文件数据需要存储，可以借助云服务器的OSS服务，也可以使用MinIO搭建自己的对象存储服务。
已解决-Sentinel控制台明明正常启动，扫描不到客户端应用
最新发布
qq_46248151的博客
10-08 315
经排查才发现，我在启动了Sentinel控制台之后，对SpringBoot应用做了配置的更新，于是重启了SpringBoot服务，这时SpringBoot是没有任何访问的。今天启动Sentinel控制台的时候，明明启动成功，无报错，浏览器能正常访问，但就是无论如何都刷新不出来应用。
Spring Boot新闻推荐系统设计与实现
2402_85758936的博客
10-04 1286
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。一旦输入系统的数据不正确，那么处理后的输出就会扩大这些错误，因此输入的数据的准确性对整个系统的性能起着决定性意义。输出是由电脑对输入的基本信息进行解决，生成高质量的有效信息，并使之具有一定的格式，提供给管理者使用，这是输出设计的主要责任和目标。
逆波兰表达式解析：从中缀到后缀的简单计算器
例如，将中缀表达式 "1 + ((2 + 3) * 4) - 5" 转换为逆波兰表达式的过程如下： 中缀表达式：1 + ((2 + 3) * 4) - 5 逆波兰表达式：1 2 3 + 4 * + 5 – 这个过程展示了如何将中缀表达式转换成逆波兰表达式，并解释...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值