逆波兰表达式计算器

前缀、中缀、后缀表达式(逆波兰表达式)：

           前缀表达式：又称波兰表达式，前缀表达式的运算符位于操作数之前

                举例：(3+4)*5-6,对应的前缀表达式为- * + 3 4 5 6

           中缀表达式：就是常见的运算表达式，如：(3+4)*5-6

           后缀表达式：又称为逆波兰表达式，与前缀表达式相似，只是运算符位于操作数之后

                举例：中缀表达式(3+4)*5-6,对应的后缀表达式为3 4 + 5 * 6 -

                         a+b   a b -

                         a+(b-c)    a b c - +

思路分析：

         例如: (3+4)* 5-6对应的后缀表达式就是34+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入栈后是-运算29,最终结果

在实际开发中应该是要将中缀表达式转为后缀表达式：

       步骤分析：

            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.alibaba.stack;

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

public class PolandNotation {
    public static void main(String[] args) {
        //中缀表达式转后缀表达式
        String expression="1+((2+3)*4)-5";
        List<String> list = toInfixExpressionList(expression);
        System.out.println(list);
        List<String> list1 = parseSuffixExpressionList(list);
        System.out.println(list1);
       /* //先定义一个逆波兰表达式(3+4)*5-6
        //String suffixExpression="3 4 + 5 * 6 -";//29
        String suffixExpression="33 44 - 6 * 4 2 / -";//-68
        List<String> list = getListString(suffixExpression);*/
        int calculate = calculate(list1);
        System.out.println(calculate);
    }
    //将中缀List转为后缀List
    public static List<String> parseSuffixExpressionList(List<String> ls){
        //定义栈
        Stack<String> s1 = new Stack<>();
        List<String> s2 = new ArrayList<>();//存储中间结果相当于s2
        //遍历ls
        for (String item:ls) {
            //如果是一个数
            if(item.matches("\\d+")){
                s2.add(item);
            }else if(item.equals("(")){
                s1.push(item);
            }else if(item.equals(")")){
                //如果是右括号")",则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃
                while (!s1.peek().equals("(")){
                    s2.add(s1.pop());
                }
                s1.pop();//将(丢弃消除小括号
            }else{
                //当item的优先级小于等于栈顶符号优先级，将s1栈顶的运算符弹出并压入到s2中,再次转到(4.1)与s1中新的栈顶运算相比较;
                while (s1.size()!=0&&Opertion.getValue(s1.peek())>=Opertion.getValue(item)){
                    s2.add(s1.pop());
                }
                //将item压入栈
                s1.push(item);
            }
        }
        //将s1中剩余的运算符依次弹出并加入s2
        while (s1.size()!=0){
            s2.add(s1.pop());
        }
        return s2;//因为存放在List中正常输出就是逆波兰表达式
    }
    //将中缀表达式转为list
    public static List<String> toInfixExpressionList(String expression){
        List<String> ls=new ArrayList<>();
        int i=0;//指针用于遍历字符串中缀表达式
        String str;//对多位数的拼接
        char c;//每次遍历一个字符，放入c中
        do {
            //如果c是非数字加到ls中
            if((c=expression.charAt(i))<48||(c=expression.charAt(i))>57){
                ls.add(""+c);
                i++;
            }else{//如果是数字，需要考虑多位数
                str="";
                while (i<expression.length()&&(c=expression.charAt(i))>=48&&(c=expression.charAt(i))<=57){
                    str+=c;//拼接
                    i++;
                }
                ls.add(str);
            }
        }while (i<expression.length());
        return ls;
    }
    //将逆波兰表达式数据及符号放入ArrayList中
    public static List<String> getListString(String suffixExpression){
        //将suffixExpression分割
        String[] spit=suffixExpression.split(" ");
        List<String> list = new ArrayList<>();
        for (String ele:spit){
            list.add(ele);
        }
        return list;
    }
    //完成对逆波兰表达式的运算
    public static int calculate(List<String> ls){
        //创建栈，只需要一个栈
        Stack<String> stack = new Stack<>();
        //遍历ls
        for (String item:ls
             ) {
            //使用正则表达式来取出数
            if(item.matches("\\d+")){//匹配多位数
                //入栈
                stack.push(item);
            }else{
                //pop出两个数并运算，再入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1=Integer.parseInt(stack.pop());
                int res=0;
                if(item.equals("+")){
                    res=num1+num2;
                }else if (item.equals("-")){
                    res=num1-num2;
                }else if(item.equals("*")){
                    res=num1*num2;
                }else if (item.equals("/")){
                    res=num1/num2;
                }else{
                    throw new RuntimeException("运算符有误");
                }
                //将res入栈
                stack.push(""+res);
            }
        }
        //最后留在stack里的就是结果
        return Integer.parseInt(stack.pop());
    }

}
//编写一个Operation可以返回运算符优先级
class Opertion{
    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 res=0;
        switch (operation){
            case "+":
                res=ADD;
                break;
            case "-":
                res=SUB;
                break;
            case "*":
                res=MUL;
                break;
            case "/":
                res=DIV;
                break;
            default:
                System.out.println("不存在该运算符");
                break;
        }
        return res;
    }
}