【数据结构与算法】逆波兰表达式计算器的实现（后缀表达式）

什么是逆波兰表达式？

把运算量写在前面，把运算算符写在后面。

中缀表达式转后缀表达式（逆波兰表达式）

1. 初始化两个栈：运算符栈s1和存储中间结果的栈s2
2. 从左到右扫描中缀表达式
3. 遇到操作数时，压入s2
4. 遇到运算符时，比较其运算符与s1栈顶的运算符的优先级
   1）如果s1为空，或者栈顶运算符为左括号“(”，则直接将次运算符入栈；
   2）若优先级比栈顶运算符高，也直接入栈
   3）若优先级比栈顶运算符低，则将s1栈顶的运算符弹出并压入s2中，然后再次回到步骤4.与s1中的新的栈顶运算符比较
5. 遇到括号时：
   1） 如果是左括号“(”，则直接压入s1
   2）如果是右括号“)”,则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
6. 重步骤2-5，直到表达式结束
7. 将s1中剩余的运算符依次弹出压入s2
8. 依次弹出s2中的元素并输出，结果的逆序就是中缀表达式对应的后缀表达式

代码实现

将一个表达式依次放入到ArrayList中

    public static List getListString(String suffixExpression){
        // 将suffixExpression分割
        String[] split=suffixExpression.split(" ");
        List list=new ArrayList();
        for (String ele:split
             ) {
            list.add(ele);
        }
        return list;
    }

中缀表达式转后缀表达式

    public static List parseSuffixExpreesionList(List s) {
        Stack s1=new Stack();
        List list = new ArrayList();
        for (String newS : s
        ) {
         // 利用正则表达式判断给数据是否为数字
            if (newS.matches("\\d+")) {
                list.add(newS);
            } else if (newS.equals("(")) {
                s1.push(newS);
            } else if (newS.equals(")")) {
                while (!s1.peek().equals("(")) {
                    list.add(s1.pop());
                }
                s1.pop();
            } else {
                while (s1.size()>0 && priority(s1.peek())>=priority(newS)) {
                    list.add(s1.pop());
                }
                s1.push(newS);
            }
        }
        // 将栈中的数据全部放到list中
        list.add(s1.pop());
        return list;
    }

判断优先级

    public static int priority(String operation) {
        int result = 0;
        if ("+".equals(operation)) {
            result = 1;
        } else if ("-".equals(operation)) {
            result = 1;
        } else if ("*".equals(operation)) {
            result = 2;
        } else if ("/".equals(operation)) {
            result = 2;
        } else {
            System.out.println("符号不存在~");
        }
        return result;
    }

逆波兰表达式的运算：

1. 从左到右进行扫描，将数字压入数字栈
2. 遇到运算符按照中缀表达式转后缀表达式的方式进行处理

 public static int calculate(List list){
        // 创建栈
        Stack stack=new Stack();
        for (String item:list
             ) {
            // 正则表达式取出数据
            if (item.matches("\\d+")){
                // 入栈
                stack.push(item);
            }else{
                // 取出两个数据进行运算
                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=num2*num1;
                }else if(item.equals("/")){
                    res=num1/num2;
                }else {
                    throw new RuntimeException("运算符有误");
                }
                stack.push(String.valueOf(res));

            }

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

通过案例进行运算：

    public static void main(String[] args) {
        // 定义一个逆波兰表达式
        String expression="2 + ( ( 6 + 4 ) * 4 ) - 50";
        List infixExpressionList=getListString(expression);
        // 将中缀表达式转换为后缀表达式
        List suffixExpression=parseSuffixExpreesionList(infixExpressionList);
        System.out.println(suffixExpression);
        // 表达式的最终结果
        System.out.println(calculate(suffixExpression));
    }

运行结果：