用棧計算數學表達式的值

計算一個簡單數學表達式（+ - * / （ ））的結果，有的這些符號的計算，常常需要看優先級來決定先算哪部分，計算機就是這個原理

兩個概念：

中綴表達式（infix Expression）：運算符寫在兩個操作數之間(運算符有一定的優先級，可以用圓括號改變運算順序)

前/后綴表達式（prefix/postfix Expression）:運算符寫在兩個表達式之前/之后（運算符沒有優先級，沒有括號，遇到運算符對它前面的兩個操作數進行求值）

如中綴表達式“6*（8+7）/5”，換成后綴表達式為“6 8 7 + * 5 /”

編程思路：

函數toPostfix(),用運算符棧來存運算符，從中綴表達式第一個字符開始，如果是數字，直接加到postfix，如果是運算符號，判斷和棧頂的優先級，不比棧頂的符號優先級低則入棧，（注意：棧中的“（”優先級最低，），否則，要棧頂出棧，如果是左括號，直接入棧，如果是右括號，則出棧，直到棧頂為左括號為止。

函數toValue(),用操作數棧來存數字，從后綴表達式第一個字符開始，是數字，就入棧，是運算符號就用棧頂的兩個數計算結果值，結果入棧。

下面是具體代碼，可以幫助理解：

       元素存儲，我選擇用順序表（SeqList<T>）

//Stack<T>接口
public interface Stack<T> {
    public abstract boolean isEmpty();

    public abstract void push(T x); // 元素x入棧

    public abstract T peek(); // 返回棧頂元素

    public abstract T pop(); // 出棧，返回出棧元素

}
//順序棧，使用順序表存儲
public class SeqStack<T> implements Stack<T> {
    private SeqList<T> list;

    public SeqStack(int length) {
        this.list = new SeqList<T>(length); // 構造容量為length的空棧
    }

    public SeqStack() {
        this(64); // 構造默認容量的空棧，調用上一個構造函數
    }

    public boolean isEmpty() {
        return this.list.isEmpty();
    }

    public void push(T x) { // 順序表表尾插入元素
        list.insert(x);
    }

    public T peek() {
        return this.list.get(list.size() - 1);
    }

    public T pop() {
        return list.remove(list.size() - 1);
    }
}
//計算數學表達式
public class Calculate {
    // 中綴表達式轉化成后綴表達式,把運算符進入到運算符棧
    public static StringBuffer toPostfix(String infix) {
        Stack<String> st = new SeqStack<String>(infix.length());
        StringBuffer sb = new StringBuffer(2 * infix.length());
        int i = 0;
        while (i < infix.length()) {
            char ch = infix.charAt(i);
            switch (ch) {
            case '+':
            case '-':
                while (!st.isEmpty() && !st.peek().equals("("))
                    // 棧頂不是“（”，那么都不比"+-"低，都要出棧
                    sb.append(st.pop());
                st.push(ch + "");
                i++;
                break;
            case '*':
            case '/':
                while (!st.isEmpty()
                        && (st.peek().equals("*") || st.peek().equals("/")))
                    sb.append(st.pop());
                st.push(ch + "");
                i++;
                break;
            case '(':
                st.push(ch + "");
                i++;
                break;
            case ')':
                String out = st.pop(); // 出棧，直到為"("
                while (out != null && !out.equals("(")) {
                    sb.append(out);
                    out = st.pop();
                }
                i++;
                break;

            default:
                while (i < infix.length() && ch >= '0' && ch <= '9') {
                    sb.append(ch);
                    i++;
                    if (i < infix.length()) {
                        ch = infix.charAt(i);
                    }
                }
                sb.append(" ");
                break;
            }

        }

        while (!st.isEmpty())
            // 剩下的出棧
            sb.append(st.pop());
        return sb;
    }

    // 后綴表達式的計算結果，運算結果入棧
    public static int toValue(StringBuffer postfix) {
        Stack<Integer> st = new SeqStack<Integer>(postfix.length());
        int value = 0;
        for (int i = 0; i < postfix.length(); i++) {
            char ch = postfix.charAt(i);
            if (ch >= '0' && ch <= '9') {
                value = 0; // 一定要先讓value初始值為0
                while (ch != ' ') {
                    value = value * 10 + ch - '0'; // 字符轉化為數值
                    ch = postfix.charAt(++i); // 如果這個字符為多位數
                }
                st.push(value);
            } else {
                if (ch != ' ') {
                    int y = st.pop(), x = st.pop(); // Integer自動轉化為int類型

                    switch (ch) {
                    case '+':
                        value = x + y;
                        break;
                    case '-':
                        value = x - y;
                        break;
                    case '*':
                        value = x * y;
                        break;
                    case '/':
                        value = x / y;
                        break;

                    }

                    st.push(value);
                }
            }

        }
        return st.pop(); // 結果就在棧頂

    }

}