4-2中缀表达式转后缀

中缀表达式转后缀

---

基本介绍

将中缀表达式转成后缀表达式。
具体步骤如下:

1. 初始化两个栈: 运算符栈s1 和 储存中间结果的栈s2;

2. 从左至右扫描中缀表达式;

3. 遇到操作数时，将其压s2;

4. 遇到运算符时，比较其与s1栈顶运算符的优先级:

   (1)如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈;

​ (2)否则，若优先级比栈顶运算符的高，也将运算符压入s1;

​ (3)否则，将s1栈顶的运 算符弹出并压入到s2中，再次转到 (4-1) 与s1中新的栈顶运算
符相比较;

5. 遇到括号时:
   (1)如果是左括号“(”， 则直接压入s1
   (2)如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为
   止，此时将这一对括号丢弃
6. 重复步骤2至5，直到表达式的最右边
7. 将s1中 剩佘的运算符依次弹出并压入s2.
8. 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

案例

package com.company.stack;

import java.beans.Expression;
import java.util.List;
import java.util.Queue;
import java.util.Stack;

/**
 * @Function :
 * date 2021/5/9 - 15:50
 *
 * How :
 */
public class PolandNotation {
    public static void main(String[] args) {
        //给定逆波兰表达式
        // （3+10）*100-6   ===》 3 10 + 100 * 600 -
        String stringExpression = "( 3 + 10 ) * 100 - 600";
        String[] Exp = stringExpression.split(" ");
        String[] strings = parseSuffixExpression(Exp);
        System.out.println("后缀表达式：");
        for (String a: strings){
            System.out.printf(a+"\t");
        }
        int calculate = calculate(strings);
        System.out.println();
        System.out.println("计算结果是："+calculate);
    }
    //转后缀表达式
    public static String[] parseSuffixExpression(String[] exp){
        //定义符号栈 s1  和 中间结果栈 s2
        Stack<String> st1 = new Stack<>();
        //实际使用中可以将其转化为list  方便输出 不用逆序
        Stack<String> st2 = new Stack<>();
        
        //遍历字符串数组
        for ( String temp : exp ) {
            //如果是数字 入数字栈
            if (temp.matches("\\d+")){
                st2.push(temp);
            }else if (st1.size()==0 || temp.equals("(")){
                st1.push(temp);
            }else if (temp.equals(")")) {
                while (!st1.peek().equals("(")){
                    st2.push(st1.pop());
                }
                st1.pop();  //消除小括号
            }else {
                //当item的优先级小于等于s1栈顶运算符，将s1栈项的运算符弹出并到s2中, 再次转到(4.1)与s1中新的栈项运算符相比较
                while (st1.size() != 0 && ( getOpration(st1.peek()) >= getOpration(temp) ) ) {
                    st2.push(st1.pop());
                }
                st1.push(temp);
            }
        }

        while (st1.size() != 0){
            st2.push(st1.pop());
        }
        int len = exp.length-3;
        String[] str = new String[len+1];
        for (int i = len; i >=0; i--) {
            str[i] = st2.pop();
        }
        return str;
    }
    //后缀表达式计算
    public static int calculate( String[] lis){
        //创建给栈，只需要一个栈即可
        Stack <String> stack = new Stack<String>();
        //遍历ls
        for(String item: lis){
            //这里使用正则表达式来取出数
            if (item.matches("\\d+")) { //匹配的是多位数
                //入栈
                stack.push(item);
            }else {
                int num1 = Integer.parseInt(stack.pop());
                int num2 = Integer.parseInt(stack.pop());
                int res = 0;
                if (item.equals("+")){
                    res = num1+num2;
                }else if (item.equals("-")){
                    res = num2 - num1;
                }else if (item.equals("*")){
                    res = num1*num2;
                }else if (item.equals("/")){
                    res = num2/num1;
                }else {
                    throw new RuntimeException("输入符号错误");
                }
                stack.push(String.valueOf(res));
            }
        }
        return Integer.parseInt(stack.pop());
    }

    public static int getOpration(String str){
        int level = 0;
        switch (str){
            case "+":
                level = 1;
                break;
            case "-":
                level = 1;
                break;
            case "*":
                level = 2;
                break;
            case "/":
                level = 2;
                break;
            case "(":
                level = 0;
                break;
            case ")":
                level = 0;
                break;
            default:
                throw new RuntimeException("错误的符号");
        }
        return level;
    }

}