数据结构（Java）-栈实现逆波兰（后缀表达式）计算器

前缀表达式（略）

中缀表达式

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

2) 中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作 ，因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作 ( 一般转成后缀表达式 .)

后缀表达式

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

2) 中举例说明： (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –

 

正常的表达式	逆波兰（后缀）表达式
a+b	a b +
a+(b-c)	a b c - +
a+(b-c)*d	a b c – d * +
a+d*(b-c)	a d b c - * +
a=1+3	a 1 3 + =

一、后缀表达式的计算机求值

思路：从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 和 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果

代码演示：

//后缀表达式的计算,输入list
    public static int calculate(List<String> list) {
        //初始化栈，创建一个
        Stack<String> stack = new Stack<>();
        //遍历
        for (String e : list) {
            //如果匹配的是多位数就入栈,使用正则表达式
            if (e.matches("\\d+")) {
                stack.push(e);
            /* 遇到符号,弹出栈顶的两个数，
             用运算符对它们做相应的计算（次顶元素 和 栈顶元素），
             并将结果入栈*/
            } else {
                int num1 = Integer.parseInt(stack.pop());
                int num2 = Integer.parseInt(stack.pop());
                int result = 0;
                switch (e) {
                    case "+":
                        result = num2 + num1;
                        break;
                    case "-":
                        result = num2 - num1;
                        break;
                    case "*":
                        result = num2 * num1;
                        break;
                    case "/":
                        result = num2 / num1;
                        break;
                    default:
                        throw new RuntimeException("符号有误！");
                }
                //结果入栈
                stack.push(Integer.toString(result));
            }
        }
        return Integer.parseInt(stack.pop());
    }

//把逆波兰表达式(后缀表达式)String的各个元素存到List中,因为List便于各种操作
    public static List<String> toSuffixExpressionList(String suffixExpression) {
        //先根据空格将字符串切分，存到String数组中
        String[] split = suffixExpression.split(" ");
        //再新建一个集合，把String数组中的元素依次添加到集合中
        List<String> list = new ArrayList<>();
        for (String e : split) {
            list.add(e);
        }
        return list;
    }

测试：
//直接使用定义好的逆波兰(后缀)表达式计算
    @Test
    public void test1() {   
        String suffixExpression = "3 4 + 5 * 6 -";// 29
        List<String> list = toSuffixExpressionList(suffixExpression);
        int res = calculate(list);
        System.out.println(res);
    }

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，直到表达式的最右边(就是2的步骤用一个循环遍历list)

7) 将s1中剩余的运算符依次弹出并压入s2

8)  依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

代码演示：

//将中缀表达式List转为后缀表达式List
    public static List<String> parseToSuffixExpressionList(List<String> list) {
        // 1)初始化两个栈：运算符栈s1和储存中间结果的栈s2
        Stack<String> s1 = new Stack<>();
        Stack<String> s2 = new Stack<>();
        // 2) 从左至右扫描中缀表达式；
        for (String e : list) {
            // 3) 遇到操作数时，将其压入s2；
            if (e.matches("\\d+")) {
                s2.push(e);
            }
            // 4) 遇到运算符时，比较其与s1栈顶运算符的优先级：
            else if (e.equals("+") || e.equals("-") || e.equals("*") || e.equals("/")) {
                // 1.如果s1非空，且栈顶运算符不是（ ，而且此运算符比栈顶运算符优先级低，
                // 就将s1栈顶的运算符弹出并压入到s2中，再与s1中新的栈顶运算符相比较；
                while (!s1.isEmpty() && !s1.peek().equals("(") && 
                        priority(e) <= priority(s1.peek())) {
                    s2.push(s1.pop());
                }
                // 2.否则如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
                if (s1.isEmpty() || s1.peek().equals("(")) {
                    s1.push(e);
                    // 3.否则若优先级比栈顶运算符的高，也将运算符压入s1；
                } else if (priority(e) > priority(s1.peek())) {
                    s1.push(e);
                }
                //  5) 遇到括号时:
            } else if (e.equals("(") || e.equals(")")) {
                //  (1) 如果是左括号“(”，则直接压入s1
                if (e.equals("(")) s1.push(e);
                //  (2) 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，
                //  直到遇到左括号为止，此时将这一对括号丢弃
                if (e.equals(")")) {
                    do {
                        s2.push(s1.pop());
                    } while (!s1.peek().equals("("));
                    s1.pop();//消除小括号“（”
                }

            } else throw new RuntimeException("符号输入有误！！");
        }
        //  6) 重复步骤2至5，直到表达式的最右边
        //  7) 将s1中剩余的运算符依次弹出并压入s2
        while (!s1.isEmpty()) {
            s2.push(s1.pop());
        }
        //  8)  依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
        List<String> newList = new ArrayList<>();
        //先用StringBuilder把s2中的元素保存，调用逆序方法后传给str，str再保存到list中
        StringBuilder stringBuilder = new StringBuilder();
        while (!s2.isEmpty()) {
            stringBuilder.append(s2.pop());
        }
        String str = String.valueOf(stringBuilder.reverse());

        for (int i = 0; i < str.length(); i++) {
            newList.add("" + str.charAt(i));
        }
        return newList;
    }

    //将中缀表达式String转为List形式
    public static List<String> toInfixExpressionList(String s) {
        List<String> list = new ArrayList<>();
        StringBuilder str;//用于拼接多位数
        int i = 0;//指针
        do {
            //如果某一位是数字，就继续向后遍历直到下一位是非数字，遍历到的数字用str拼接成多位数
            if (String.valueOf(s.charAt(i)).matches("\\d")) {
                str = new StringBuilder();
                while (i < s.length() && String.valueOf(s.charAt(i)).matches("\\d")) {
                    str.append(s.charAt(i));
                    i++;
                }
                list.add(String.valueOf(str));
            }
            //如果某位不是数字，就直接加进list中
            else {
                list.add("" + s.charAt(i));
                i++;
            }
        } while (i < s.length());
        return list;
    }

    //判断运算符优先级
    public static int priority(String s) {
        if (s.equals("+") || s.equals("-")) {
            return 0;
        } else if (s.equals("*") || s.equals("/")) {
            return 1;
        } else throw new RuntimeException("判断优先级失败！错误的输入！");
    }

注：代码确实存在优化的空间，而且不支持小数，不能过滤特殊字符，这里只是做初步演示

测试：

@Test
    public void test2() {
        //先将中缀表达式转为后缀表达式，再计算
        String s = "1+((2+3)*4)-5";
        System.out.println("原始中缀表达式为：" + s);
        List<String> list = toInfixExpressionList(s);//string -> list
        List<String> newlist = parseToSuffixExpressionList(list); // InfixList -> SuffixList
        System.out.println("转成后缀表达式为：" + newlist);
        System.out.println("计算结果为" + calculate(newlist));
    }


结果：
原始中缀表达式为：1+((2+3)*4)-5
转成后缀表达式为：[1, 2, 3, +, 4, *, +, 5, -]
计算结果为16