栈的应用——四则运算表达式求值

    若要计算机具有处理标准表达式的能力，最重要的有两步：

        1、将中缀表达式转化为后缀表达式

        2、将后缀表达式进行运算得出结果

    中缀表达式：标准四则运算表达式，即“8+（3-2*4）*10+2/2”

    后缀表达式：所有的符号都是要在运算数字的后面出现。例：

            将“8+（3-2*4）*10+2/2”转为后缀表达式为：“8 3 2 4 * - 10 * + 2 2 / +”

    中缀表达式转后缀的规则：

            1、从左至右遍历中缀表达式，遇到数字就输出，即成为后缀表达式的一部分；

            2、如果是左括号，就压入栈，如果是右括号，则栈中元素依次出栈，直到栈中左括号出栈。

            3、如果是+、-运算符，若栈不为空，栈中元素依次出栈， 直到栈为空或遇到左括号，而后再将运算符压入栈，

            4、如果是*、/运算符，若栈不为空，且栈顶元素为*或/，则栈顶元素依次出栈，而后运算符入栈。

    代码如下：

 public String infixToSuffix(String infixExpression) {
        String suffixExpression = "";
        for (int i = 0; i < infixExpression.length(); i++) {
            char c = infixExpression.charAt(i);
            if (c == '+' || c == '-') {
                while (!stack.isEmpty() && stack.peek() != '(') {
                    suffixExpression += String.valueOf(stack.pop());
                }
                stack.push(c);
            } else if (c == '*' || c == '/') {
                while (!stack.isEmpty() && (stack.peek() == '*' || stack.peek() == '/')) {
                    suffixExpression += String.valueOf(stack.pop());
                }
                stack.push(c);
            } else if (c == ')') {
                while (!stack.isEmpty() && stack.peek() != '(') {
                    suffixExpression += String.valueOf(stack.pop());
                }
                stack.pop();
            } else if (c == '(') {
                stack.push(c);
            } else if (c != ' '){
                suffixExpression += String.valueOf(c);
            }
        }
        while (!stack.isEmpty()) {
            suffixExpression += String.valueOf(stack.pop());
        }
        return suffixExpression;
    } 

        后缀表达式运算规则：

        从左至右遍历表达式的每个数字和符号，遇到数字就进栈，遇到的是符号，将处于栈顶的两个数字出栈，进行运算，运算结果进栈，一直到最终获得结果。

        

    // 后缀表达式计算
    public void expressionCalculation(String suffixExpression) {
        StringTokenizer token = new StringTokenizer(suffixExpression);
        java.util.Stack<Double> numStack = new java.util.Stack<>();
        while(token.hasMoreElements()) {
            String c = token.nextToken().trim();
            if (c.equals("/") || c.equals("+") || c.equals("-") || c.equals("*")) {
                numStack.push(calculation(numStack.pop(), numStack.pop(), c));
            } else {
                numStack.push(Double.valueOf(c));
            }
        }
        System.out.println(numStack.peek());
    }

    private double calculation(double num1, double num2, String operator) {
        double result = 0.0;
        switch (operator) {
            case "+":
              result =  num2 + num1;
              break;
            case "-":
                result =  num2 - num1;
                break;
            case "*":
                result =  num2 * num1;
                break;
            case "/":
                result =  num2 / num1;
                break;
        }
        return result;
    }

      四则运算表达式完整代码：

 private double calculation(double num1, double num2, String operator) {
        double result = 0.0;
        switch (operator) {
            case "+":
              result =  num2 + num1;
              break;
            case "-":
                result =  num2 - num1;
                break;
            case "*":
                result =  num2 * num1;
                break;
            case "/":
                result =  num2 / num1;
                break;
        }
        return result;
    }

    public double evaluateExpression(String expression) {
        Stack<Double> operandStack = new LinkedListStack<>();
        Stack<Character> operatorStack = new LinkedListStack<>();
        StringTokenizer tokens = new StringTokenizer(expression, "()+-*/", true);
        while (tokens.hasMoreTokens()) {
            String token = tokens.nextToken().trim();
            if (token.length() == 0) {
                continue;
            }
            else if (token.charAt(0) == '+' || token.charAt(0) == '-') {
                while (!operatorStack.isEmpty() && operatorStack.peek() != '(') {
                    operandStack.push(calculation(operandStack.pop(), operandStack.pop(), String.valueOf(operatorStack.pop())));
                }
                operatorStack.push(token.charAt(0));
            } else if (token.charAt(0) == '*' || token.charAt(0) == '/') {
                while (!operatorStack.isEmpty() && (operatorStack.peek() == '*' || operatorStack.peek() == '/')) {
                    operandStack.push(calculation(operandStack.pop(), operandStack.pop(), String.valueOf(operatorStack.pop())));
                }
                operatorStack.push(token.charAt(0));
            } else if (token.trim().charAt(0) == '(') {
                operatorStack.push('(');
            } else if (token.trim().charAt(0) == ')') {
                while (!operatorStack.isEmpty() && operatorStack.peek() !='(') {
                    operandStack.push(calculation(operandStack.pop(), operandStack.pop(), String.valueOf(operatorStack.pop())));
                }
                operatorStack.pop();
            } else {
                operandStack.push(new Double(token));
            }
        }
        while(!operatorStack.isEmpty()) {
            operandStack.push(calculation(operandStack.pop(), operandStack.pop(), String.valueOf(operatorStack.pop())));
        }
        return operandStack.peek();
    }