07.解析四则运算表达式并计算结果

企业的笔试题或计算机比赛中经常出现解析字符串类型的四则运算表达式并得到结果。
此处需要利用两个栈来解决这个问题。

1. 操作数栈

用于保存被计算的数字或者计算过程的中间值

2. 符号栈

用于保存表达式中的各种运算符号和括号

3. 设计思路

3.1 四则运算符号

符号入栈前先检查符号栈栈顶，如果栈顶符号优先级不低于当前入栈符号，则使用栈顶符号对操作数栈进行计算，并将计算结果存入操作数栈

3.2 括号

如果是(，则直接入栈
如果是)，立刻对取出两个操作数栈的数据，并和符号栈栈顶元素计算，计算结果存入操作数栈。
直至符号栈栈顶为(，最后将(出栈

3.3 示例演示

比如需要计算算式3+((3+2)-2*2)

数据入栈

此时即将入栈的是),根据上面的规则，此时需要将操作数栈中的数据拿出与符号栈中的符号进行计算

出栈计算直至遇到左括号

后续符号继续入栈

将计算结果重新入栈，后续符号继续入栈

乘号入栈时需要检查，如果当前符号栈的栈顶也是乘除法,则可以优先计算，当然此处也可以留到最后计算

乘号入栈

最后一个数字入栈，最终的)触发了最终的计算

最后一个数字入栈，红色区域触发计算

2x2的结果入栈，继续触发计算

继续触发计算

最终得到计算结果：4

4. Java代码实现

package com.test.calculation;
import java.util.Stack;
public class AnalysisCalculation {  
    /**
     * 计算表达式的结果
     * @param formula
     * @return
     */
    public static double getResult(String formula) {
        boolean isRightFormula = validate(formula);
        if(!isRightFormula) {
            throw new NumberFormatException("表达式括号不匹配:"+formula);
        }
        Stack nums = new Stack();//操作数栈
        Stack oper = new Stack();//运算符栈
        char[] cs = formula.toCharArray();      
        int startPos = 0;
        int endPos = 0;
        for(char c : cs) {
            //乘除法处理
            if(c == '*' || c == '/') {
                //获得操作符前的数字
                String n = formula.substring(startPos, endPos);
                if(n.isEmpty()) {
                    oper.add(c);
                }else {
                    double d2 = Double.parseDouble(n);  
                    //查看运算符栈栈顶
                    if(oper.isEmpty()) {
                        //数字入操作数栈
                        nums.push(d2);
                        //第一个运算符，直接入栈
                        oper.push(c);
                    }else {
                        //已有运算符
                        char top_oper = oper.peek();
                        if(top_oper == '*' || top_oper == '/') {
                            //当前栈顶是乘除法
                            double d1 = nums.pop();
                            char op = oper.pop();
                            double x = compute(d1, d2, op);
                            nums.push(x);       
                        }else {
                            nums.push(d2);
                        }
                        oper.add(c);
                    }
                }
                startPos = endPos + 1;          
            }
            //加减法处理
            if(c == '+' || c == '-') {
                //获得操作符前的数字
                String n = formula.substring(startPos, endPos);
                if(n.isEmpty()) {
                    oper.add(c);
                }else {
                    double d2 = Double.parseDouble(n);  
                    //查看运算符栈栈顶
                    if(oper.isEmpty()) {
                        //数字入操作数栈
                        nums.push(d2);
                        //第一个运算符，直接入栈
                        oper.push(c);
                    }else {
                        //已有运算符
                        char top_oper = oper.peek();
                        if(top_oper != '(') {
                            //如果操作符栈顶是加减法或乘除法
                            char op = oper.pop();
                            double d1 = nums.pop();
                            double dx = compute(d1, d2, op);
                            nums.push(dx);
                            
                        }else {
                            nums.push(d2);
                        }
                        oper.add(c);
                    }
                }
                startPos = endPos + 1;
            }
            //(处理：直接入栈
            if(c == '(') {
                oper.add('(');
                startPos++;
            }
            //)处理，计算数据直至遇到左括号
            if(c == ')') {
                //得到当前数字
                String n = formula.substring(startPos, endPos);
                double dx = Double.parseDouble(n);  
                //将数字入操作数栈
                nums.push(dx);
                //符号栈栈顶出栈
                char op = oper.pop();
                //循环计算直至遇到左括号
                while(op != '(') {
                    double d2 = nums.pop();
                    double d1 = nums.pop();
                    double x = compute(d1, d2, op);
                    nums.push(x);
                    op = oper.pop();
                }
                startPos = endPos + 1;
            }
            endPos++;
        }
        //取得最后一个数字
        String n = formula.substring(startPos);
        double d2 = 0;
        if(!n.isEmpty()) {
            //如果有数字
            d2 = Double.parseDouble(n);
        }else {
            //如果符号以右括号结尾
            d2 = nums.pop();        
        }
        //将栈中剩余的数字拿出进行计算
        while(!oper.isEmpty()) {
            char op = oper.pop();
            double d1 = nums.pop();
            double x = compute(d1, d2, op);
            d2 = x;
        }   
        return d2;
    }
    /**
     * 根据操作符计算两个数据的结果
     * @param d1
     * @param d2
     * @param op
     * @return
     */
    public static double compute(double d1, double d2, char op) {
        if(op == '+') {
            return d1+d2;
        }else if(op == '-') {
            return d1-d2;
        }else if(op == '*') {
            return d1*d2;
        }else{
            return d1/d2;
        }
    }   
    /**
     * 验证括号格式是否匹配
     * @param formula
     * @return
     */
    public static boolean validate(String formula) {
        char[] cs = formula.toCharArray();
        Stack s = new Stack();
        for(char c : cs) {
            if(c == '(') {
                s.push(c);
            }else if(c == ')') {
                try {
                    char top = s.pop();
                    if(top != '(') {
                        return false;
                    }
                }catch(Exception e) {
                    return false;
                }   
            }
        }
        if(s.isEmpty()) {
            return true;
        }else {
            return false;
        }
    }   
    public static void main(String[] args) {
        String str = "3+((3+2)-2*2)";
        double x = AnalysisCalculation.getResult(str);
        System.out.println(x);
    }
}