中缀，后缀表达式实现简单计算器

1.逆波兰表达式简单计算器

2.中缀转后缀表达式简单计算器

例如：(3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 -，针对后缀表达式求值步骤如下：

1. 从左至右扫描，将 3 和 4 压入堆栈；
2. 遇到 + 运算符，因此弹出 4 和 3（4 为栈顶元素，3 为次顶元素），计算出 3+4 的值，得 7，再将 7 入栈；
3. 将 5 入栈；
4. 接下来是 × 运算符，因此弹出 5 和 7，计算出 7×5=35，将 35 入栈；
5. 将 6 入栈；
6. 最后是 - 运算符，计算出 35-6 的值，即 29，由此得出最终结果。

import javax.print.attribute.standard.PrinterMakeAndModel;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * 将字符串放进Arraylist
 * 建立一个栈来放数字
 * 计算
 */
public class PolandNotation {
    public static void main(String[] args) {
        //定义逆波兰表达式
        String suffixExpression = "4 5 * 8 - 60 + 8 2 / +";
        //数字之间和符号空格隔开
        List<String> stringList = MakeStringToList(suffixExpression);
        int res = calculator(stringList);
        System.out.println("计算结果"+res);
    }

    public static List<String> MakeStringToList(String suffixExpression){
        String[] strings = suffixExpression.split(" ");
        List<String> list = new ArrayList<>();
        for (String item:strings){
            list.add(item);
        }
        return list;
    }

    public static int calculator(List<String> arrayList){
        Stack<String> stack = new Stack();
        String res;
        for(String item:arrayList){
            if (item.matches("\\d+")){
                stack.push(item);
            }else {
                int num2 =Integer.parseInt(stack.pop());
                int num1 =Integer.parseInt(stack.pop());
                if (item.equals("+")){
                    res = ""+(num1+num2);
                    stack.push(res);
                } else if (item.equals("-")) {
                    res = ""+(num1-num2);
                    stack.push(res);
                } else if (item.equals("*")) {
                    res = ""+num1*num2;
                    stack.push(res);
                } else if (item.equals("/")) {
                    res = ""+num1/num2;
                    stack.push(res);
                }else {
                    throw new RuntimeException();
                }
            }
        }
        return Integer.parseInt(stack.pop());
    }
}

2.中缀转后缀表达式简单计算器

import javax.print.attribute.standard.PrinterMakeAndModel;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/*
中缀转后缀表达式思路：
1.中缀转成ArrayList
2.将中缀表达式转为后缀表达式，算法如上图
 */

public class PolandNotation02 {
    public static void main(String[] args) {
        String expression = "1+((7+3)-5)";
        List<String> infixExpressionList = toInfixExpressionList(expression);
        List<String> list = parseSuffixExpressionList(infixExpressionList);
        int res = calculator(list);
        System.out.println(res);


    }
    //将中缀表达式转为对应得list
    public static List<String> toInfixExpressionList(String s){
        ArrayList<String> ls = new ArrayList<>();
        int i = 0 ; //指针用于遍历
        String str; //对多位数的拼接
        char c;     //遍历的每一个字符存入c
        do {
            //如果是非数字加入到ls
            if ((c=s.charAt(i))<48|| (c=s.charAt(i))>57){
                ls.add(""+c);
                i++; //i后移
            }else {
                str = ""; //先将str置成空串
                while (i< s.length()&&(c=s.charAt(i))>=48&&(c=s.charAt(i))<=57){
                    str+=c;
                    i++;
                }
                ls.add(str);
            }
        }while (i<s.length());
        return ls;

    }
    //"1+((2+3)-5)"
    public static List<String> parseSuffixExpressionList(List<String> ls) {
        //定义两个栈，存储中间结果的List和存储符号的栈
        Stack<String> s1 = new Stack<>();
        ArrayList<String> s2 = new ArrayList<>();
        //遍历ls
        for (String item : ls)
            if (item.matches("\\d+")) {
                s2.add(item);
            } else if (item.equals("(")) {
                s1.push(item);
            } else if (item.equals(")")) {
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();
            } else {

                while (!s1.empty() && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                s1.push(item);
            }
        while (s1.size()!=0){
            s2.add(s1.pop());
        }
        return s2;
        //因为list是正常输出就是栈输出的逆序
    }

    public static int calculator(List<String> arrayList){
        Stack<String> stack = new Stack();
        String res;
        for(String item:arrayList){
            if (item.matches("\\d+")){
                stack.push(item);
            }else {
                int num2 =Integer.parseInt(stack.pop());
                int num1 =Integer.parseInt(stack.pop());
                if (item.equals("+")){
                    res = ""+(num1+num2);
                    stack.push(res);
                } else if (item.equals("-")) {
                    res = ""+(num1-num2);
                    stack.push(res);
                } else if (item.equals("*")) {
                    res = ""+num1*num2;
                    stack.push(res);
                } else if (item.equals("/")) {
                    res = ""+num1/num2;
                    stack.push(res);
                }else {
                    throw new RuntimeException();
                }
            }
        }
        return Integer.parseInt(stack.pop());
    }
}


//编写一个类，可以返回一个运算符的优先级
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 getValue(String operation){
        int result = 0;
        switch (operation){
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
        }
        return result;
    }
}