java 中缀表达式到后缀表达式的转换。

最新推荐文章于 2024-09-21 17:41:47 发布

imyyn

最新推荐文章于 2024-09-21 17:41:47 发布

阅读量269

点赞数

CC 4.0 BY-SA版权

分类专栏： Java 练习

本文链接：https://blog.youkuaiyun.com/qq_43132512/article/details/94610970

Java 同时被 2 个专栏收录

10 篇文章

订阅专栏

练习

8 篇文章

订阅专栏

本文详细解析了中缀表达式转换为后缀表达式的算法过程，包括数字和运算符的处理规则，以及如何使用Java实现这一转换。通过具体示例，读者可以深入理解算法的工作原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

算法思想
数字直接加入后缀表达式
运算符时：
a.若为’(’，入栈；
b.若为’)’，则依次把栈中的运算符加入后缀表达式，直到出现’(’，并从栈中删除’)’；
c.若为’+’，’-’，’*’，’/’，
　·栈空，入栈；
　·栈顶元素为’(’，入栈；
　·高于栈顶元素优先级，入栈；
　·否则，依次弹出栈顶运算符，直到一个优先级比它低的运算符或’('为止；
d.遍历完成，若栈非空依次弹出所有元素。
代码

import java.util.Scanner;
import java.util.Stack;

class Test {
    public static void main(String[] args) {
        String expression = "";
        Scanner input = new Scanner(System.in);
        expression = input.nextLine();
        input.close();
        System.out.println(change(expression));
    }

    public static String change(String expression) {
        String postfixExpression = "";                                  // 记录后缀表达式
        Stack<String> symbolStack = new Stack<>();                      // 符号栈
        String[] expressionList = expression.split(" ");                // 根据空格拆分存放在数组中
        for (String str : expressionList) {
            if (!isOperator(str)) {                                     // 不是操作符时
                postfixExpression += (str + " ");                       // 记录
                continue;
            }
            if (symbolStack.empty()||str.equals("(")) {                 // 开始时栈为空时 或者 遇到"("
                symbolStack.push(str);
                continue;
            }
            if (str.equals(")")) {                                      // 遇到")"
                while (true) {                                          // 不为空
                    if (symbolStack.peek().equals("(")) {               // 如果遇到左括号的时候退出循环
                        symbolStack.pop();
                        break;
                    }
                    postfixExpression += (symbolStack.pop() + " ");     // 记录
                }                                                       // 将当前符号入栈
                continue;
            }
            if (!comp(symbolStack.peek(), str)) {                       // 判断是否出栈
                while (!symbolStack.empty()) {                          // 不为空
                    if (symbolStack.peek().equals("("))                 // 如果遇到左括号的时候退出循环
                        break;
                    postfixExpression += (symbolStack.pop() + " ");     // 记录
                }
            }
            symbolStack.push(str);                                      // 将当前符号入栈
        }
        while (!symbolStack.empty())                                    // 最后将剩余的出栈
            postfixExpression += (symbolStack.pop() + " ");
        return postfixExpression.trim();
    }

    public static boolean isOperator(String str) {                      // 是否为操作符
        String[] operator = { "+", "-", "*", "/", "(", ")" };
        for (String ope : operator) {
            if (str.equals(ope))
                return true;
        }
        return false;
    }

    public static boolean comp(String str1, String str2) {              // 判断操作符str2优先级是否比str1大
        char c1 = str1.charAt(0);
        char c2 = str2.charAt(0);
        char[] operator = "+-*/".toCharArray();
        int n1 = -1, n2 = -1;
        for (int i = 0; i < operator.length; i++) {
            if (operator[i] == c1)
                n1 = i;
            if (operator[i] == c2)
                n2 = i;
        }
        return n2 / 2 > n1 / 2;
    }
}