使用堆栈将缺少左括号的表达式补全并计算其值

问题描述：输入一个缺少左括号的表达式，打印出其补全括号的中序表达式，并计算表达式的值。例如给定表达式：

1+2) * 3-4) * 5-6)))

得到输出：

((1+2) * ((3-4) * (5-6)))

计算得到其值为3
问题分析：计算表达式的问题通常使用堆栈。有的算法中利用操作符的优先级以及复杂的记录过程，其实只要利用好堆栈的特性，任何多余的操作都是完全没有必要的。这里首先考虑计算出表达式的值的问题，以此思路推及补全表达式的问题。
由于所计算的表达式是由数字和操作符构成的，因而解析表达式的时候需要使用两个堆栈分别存放数字和操作符。将表达式分别入栈，每当遇到右括号时出栈计算子表达式，将结果再次入栈参与下一次的计算。

public class Test1{

    public static boolean isNumber(char s) {
        return (48<=s&&s<=57)?true:false;
    }   
    public static boolean isOpr(char s) {
        return (s=='+'||s=='-'||s=='*'||s=='/')?true:false;
    }

    public static void main(String[] args) {
        In in=new In("D:\\expression.txt");
        String string=in.readAll();
        char[] word=string.toCharArray();       
        ListStack<Character> oprStack=new ListStack<>();// 数字
        ListStack<Integer> numStack=new ListStack<>();// 操作符        
        for (int i = 0; i < word.length; i++) {
            if (isNumber(word[i])) {// 数字
                numStack.push(word[i]-48);
            }else if (isOpr(word[i])) {// 操作符
                oprStack.push(word[i]);
            }else if (word[i]==')') {
                // 遇到右括号的时候计算子表达式
                int right=numStack.pop();
                int left=numStack.pop();
                char opr=oprStack.pop();
                int result=0;
                switch (opr) {
                case '+':
                    result=left+right;
                    break;
                case '-':
                    result=left-right;
                    break;
                case '*':
                    result=left*right;
                    break;
                case '/':
                    result=left/right;
                    break;
                default:
                    break;
                }
                // 最后将子表达式的结果入栈参与下次计算
                numStack.push(result);
            }
        }
        // 程序最后操作符的堆栈为空，数字的堆栈中就是最后的计算结果
        System.out.println(numStack.pop());
    }
}

可见整个算法是非常简单的。接着要将表达式的左括号补全，应该如何做呢？首先会想到要去找插入左括号的位置，而左括号又取决于右括号的迭代层次，因此要想通过记录位置的方法来解决此问题不是很容易。
而通过分析计算表达式的值的问题，我们可以得到启发：通过将子表达式的结果逐层代入父表达式，就可以利用堆栈非常简单的解决问题，从而有以下解决方案。

public class Test2{
    public static void main(String[] args) {
        In in=new In("D:\\expression.txt");
        String string=in.readAll();
        String[] strings =string.split("");
        Stack<String> exprStack=new Stack<>();
        for (int i = 0; i < strings.length; i++) {
            // 将表达式内容全部入栈
            if (!strings[i].equals(")")) {
                exprStack.push(strings[i]);
            }else {
                // 在遇到右括号的时候将子表达式用一个String对象表示并入栈以代入父表达式
                String right=exprStack.pop();
                String opr=exprStack.pop();
                String left=exprStack.pop();
                String expr="("+left+opr+right+")";// 补全左右括号
                exprStack.push(expr);
            }
        }
        System.out.println(exprStack.pop());
    }
}

上述算法关键在于将子表达式用一个String对象表示，就如同一个计算的结果，入栈后代入父表达式。
总结：将子表达式用一个结果表示，逐层代入父表达式，可以利用堆栈处理表达式的补全问题。