栈（后缀表达式的计算）

简单后缀表达式的计算

就我个人来说，后缀表达式看起来很别扭，但是从变成来看，后缀表达式的处理比中缀表达式的处理方便很多。

中缀表达式：( 30 + 4 ) x 5 - 6 = 164
后缀表达式：30 4 + 5 x 6 - = 164

对于中缀表达式而言，一般需要两个栈：数栈和符号栈，并且处理过程中需要注意括号运算。就上面的中缀表达式来看，先计算括号里的+，再计算x，最后计算 - 。但是，就后缀表达式来看，表达式中的运算符号出现顺序与中缀表达式对应的计算顺序是一样的，因此，计算后缀表达式只需一个栈，存放数值即可。若扫描到数值，则直接入栈；若扫描到运算符，则pop两个数值做运算，再将运算结果入栈，最后，栈中必定只剩下一个数值，即结果。

代码如下（此段代码是学习别人的，稍许修改）：

public class CalculatorBehind {
    public static void main(String[] args){
        // 后缀表达式
        String expr = "4 5 * 8 - 60 + 8 2 / +";

        ArrayList<String> expr_split = getArrayListExpression(expr);
        int res = calculate(expr_split);
        System.out.println(expr_split + " -> " + res);

    }

    // 扫描后缀表达式，依次分割数值、运算符
    public static ArrayList<String> getArrayListExpression(String expr){
        // 后缀表达式以空格隔开，因此以空格来分割后缀表达式
        String[] subExpr = expr.split(" ");
        // 创建存放分割后后缀表达式的ArrayList
        // 将分割后的各个字符串依次添加到ArrayList中
        ArrayList<String> expression = new ArrayList<String>(Arrays.asList(subExpr));
        // 返回结果
        return expression;
    }

    // 计算后缀表达式的结果，并返回
    public static int calculate(ArrayList<String> expression){
        // 创建栈，只存放数值，无需存放运算符
        Stack<String> stack = new Stack<String>();
        // 遍历分割后的后缀表达式
        for (String s: expression){
            // 如果是数值，则入栈
            if (s.matches("\\d+")){
                stack.push(s);
            }
            // 如果是运算符，则从栈中pop两个数值，作运算，再将结果入栈
            else{
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int result = 0;
                switch (s){
                    case "+":
                        result = num1 + num2;
                        break;
                    case "-":
                        result = num1 - num2;
                        break;
                    case "*":
                        result = num1 * num2;
                        break;
                    case "/":
                        result = num1 / num2;
                        break;
                    default:
                        break;
                }
                stack.push(String.valueOf(result));
            }
        }
        // 返回结果
        return Integer.parseInt(stack.pop());
    }
}

---

中缀表达式转换为后缀表达式

我们在做数学描述时，都是利用中缀表达式实现，但是，计算机实现后缀表达式的计算却更简单。因此，可以将中缀表达式转换为后缀表达式，再进行计算。

处理思路：

• 初始化两个栈，一个存放结果，另一个存放运算符
• 逐个扫描表达式
  • 若字符是数字，则直接入栈（结果栈）
  • 若字符是运算符
    • 若符号栈空，或者该字符为’(’，则直接入栈（符号栈）
    • 若该字符优先级大于栈顶字符优先级，且不为’)’，则直接入栈（符号栈）
    • 若该字符为’)’，从符号栈中不断pop元素，并push至结果栈，直到符号栈栈顶为’(’，并pop符号栈栈顶
    • 若该字符优先级小于或等于栈顶字符优先级，从符号栈中不断pop元素，并push至结果栈，直到该字符优先级大于栈顶字符优先级，或者符号栈空，或者符号栈栈顶为’(’。并将该字符入符号栈
• 结果栈中的元素从栈底至栈顶输出，即为后缀表达式

代码如下（利用List实现的）：

public class MiddleToBehind {
    public static void main(String[] args){
        String express = "( 1 - 3 ) * 2 + 10 / 1 - 3";
        List<String> express_behind = middle_to_behind(express);
        System.out.print(express_behind + " = ");
        System.out.println(calculate_with_behind(express_behind));
    }

    // 将中缀表达式转换为后缀表达式
    public static List<String> middle_to_behind(String expression_middle){
        // 符号栈
        List<String> operStack = new ArrayList<String>();
        // 存放结果的栈
        List<String> resStack = new ArrayList<String>();

        // 将中缀表达式按照空格分割
        String[] sub_expression = expression_middle.split(" ");

        // 逐一处理字符
        for (String str:sub_expression){
            // 如果是数字，则直接入栈（结果栈）
            if (str.matches("\\d+")){
                resStack.add(str);
            }
            // 如果是运算符
            else {
                // 如果符号栈空，或者该字符是（，则直接入栈（符号栈）
                if (operStack.isEmpty() || str.equals("(")){
                    operStack.add(str);
                }
                // 如果该字符的优先级大于栈顶字符优先级，则直接入栈（符号栈）
                else if (!str.equals(")") && priority(str)>priority(operStack.get(operStack.size()-1))){
                    operStack.add(str);
                }
                // 如果该字符是 ），不断pop，直到栈顶字符是（，并删除（
                else if (str.equals(")")){
                    while (!operStack.get(operStack.size()-1).equals("(")){
                        resStack.add(operStack.get(operStack.size()-1));
                        operStack.remove(operStack.size()-1);
                    }
                    operStack.remove(operStack.size()-1);
                }
                // 如果该字符的优先级小于等于栈顶字符优先级，不断pop，直到栈顶字符是（，或者该字符的优先级大于栈顶字符优先级
                else if (priority(str) <= priority(operStack.get(operStack.size()-1))){
                    while (!operStack.get(operStack.size()-1).equals("(") && priority(str)<=priority(operStack.get(operStack.size()-1))){
                        resStack.add(operStack.get(operStack.size()-1));
                        operStack.remove(operStack.size()-1);
                        // 如果符号栈空，则停止pop
                        if (operStack.isEmpty()){
                            break;
                        }
                    }
                    operStack.add(str);
                }
            }
        }

        // 将符号栈元素pop，并push至结果栈
        while (!operStack.isEmpty()){
            resStack.add(operStack.get(operStack.size()-1));
            operStack.remove(operStack.size()-1);
        }

        // 结果栈的逆序输出即为转换得到的后缀表达式
        return resStack;
    }

    // 根据后缀表达式计算
    public static int calculate_with_behind(List<String> express_behind){
        // 计算结果
        int result = 0;
        // 运算栈
        List<String> resultStack = new ArrayList<String>();
        // 计算
        for (String str: express_behind){
            if (str.matches("\\d+")){
                resultStack.add(str);
            }
            else{
                int num2 = Integer.parseInt(resultStack.get(resultStack.size()-1));
                resultStack.remove(resultStack.size()-1);
                int num1 = Integer.parseInt(resultStack.get(resultStack.size()-1));
                resultStack.remove(resultStack.size()-1);
                switch (str){
                    case "+":
                        result = num1 + num2;
                        break;
                    case "-":
                        result = num1 - num2;
                        break;
                    case "*":
                        result = num1 * num2;
                        break;
                    case "/":
                        result = num1 / num2;
                        break;
                    default:
                        break;
                }
                resultStack.add(String.valueOf(result));
            }
        }
        return Integer.parseInt(resultStack.get(resultStack.size()-1));
    }

    // 判断运算符优先级
    public static int priority(String str){
        if (str.equals("(*)") || str.equals(")")){
            return 3;
        }
        else if (str.equals("*") || str.equals("/")){
            return 2;
        }
        else if (str.equals("+") || str.equals("-")){
            return 1;
        }
        else {
            return 0;
        }
    }
}