表達式求值--Java實現

/*將中綴表達式--轉化為后綴表達式--屬於棧的一種應用
 *具體思路：
 *1.掃描字符串，遇到操作數字符直接不管，存到一個字符串里邊
 *2.操作符優先級比較--定義了方法
 *      棧中優先級高：出棧存進字符串，當前的操作符進棧
 *      當前操作符優先級高，直接進棧
 *        對於左邊括號直接進棧，右邊括號涉及棧中出棧
 *3.掃描完了在將棧中的出棧和操作數存儲在一起
 *轉化完直觀的表現：操作數相對位置不變，操作符相對位置相反
 * */
public class IntoSuffixExpression {
    private CharStack stack;
    private String input;
    private String output = "";
    
    public IntoSuffixExpression(String in) {
        input = in;
        stack = new CharStack(input.length());
    }
    
    //轉化為后綴表達式
    public String doTrans(){
        for(int i = 0; i < input.length();i++){
            char ch = input.charAt(i);
            stack.displayStack("For " + ch + " ");
            /*分析讀到的元素的類型--操作符/操作數(默認添加到輸出字符串中)
             *對於操作符分類並進行優先級比較   乘除優先級高於加減*/
            switch(ch){
                case '+':
                case '-':
                    gotOper(ch,1);//需要判斷優先級prec1：設定的是當前的優先級
                    break;
                case '*':
                case '/':
                    gotOper(ch,2);//需要判斷優先級
                    break;
                case '(':
                    stack.push(ch);//左括號優先級最高直接進棧
                    break;
                case ')':
                    gotParent(ch);//碰到右邊括號涉及出棧
                    break;
                default:
                    output = output + ch;//是操作數就直接存在輸出字符串中
                    break;
            }
        }
        //打印戰中的操作符返回后綴表達式字符串
        while(!stack.isEmpty()){
            stack.displayStack("while");
            output = output + stack.pop();
        }
        stack.displayStack("end");
        return output;
    }

    //比較當前的操作符與棧里面的操作符優先級--進行不同的操作
    public void gotOper(char opThis, int prec1) {
        while(!stack.isEmpty()){
            char opTop = stack.pop();
            if(opTop == '('){  //如果棧中頂是左邊括號就進去跳出循環
                stack.push(opTop);
                break;
            }
            else{
                int prec2;
                //記錄棧中操作符優先級--加減優先級是1乘除優先級是2
                if(opTop == '+' || opTop == '-'){
                    prec2 = 1;
                }
                else{
                    prec2 = 2;
                }
                //棧中優先級小結束比較--當前執行進棧操作
                if(prec2 < prec1){
                    stack.push(opTop);
                    break;
                }
                //棧中優先級大就出棧存儲在字符串中
                else{
                    output = output + opTop;
                }
            }
        }
        //棧為空就直接進棧或者遇到左邊括號也是直接進棧或者棧存儲比棧中優先級小的
        stack.push(opThis);
    }
    
    //越到右邊括號進行出棧的操作--直到遇到左邊括號
    public void gotParent(char ch){
        while(!stack.isEmpty()){
            char chx = stack.pop();
            if(chx == '('){
                break;
            }
            else{
                output = output + chx;
            }
        }
    }
    
    

}

/*計算后綴表達式的值--也用的是棧
 * */
public class CalculateSuffixExpression {
    private MyStack stack;
    private String input;
    
    //注意這里傳入的字符串是后綴的表達式
    public CalculateSuffixExpression(String in) {
        input = in;
    }
    
    //數字進棧，操作符棧中元素出棧對應相應的操作
    public long calculateValue(){
        stack = new MyStack(20);
        char ch;
        int j;
        long num1,num2,interAns;
        for(j = 0;j < input.length();j++){
            ch = input.charAt(j);
            stack.displayStack("" + ch + "");
            if(ch >= '0' && ch <= '9'){  //操作數
                stack.push((long)(ch - '0'));
            }
            else{
                num2 = stack.pop();
                num1 = stack.pop();
                switch(ch){
                    case'+':
                        interAns = num1 + num2;
                        break;
                    case'-':
                        interAns = num1 - num2;
                        break;
                    case'*':
                        interAns = num1 * num2;
                        break;
                    case'/':
                        interAns = num1 / num2;
                        break;
                    default:
                        interAns = 0;
                }
                stack.push(interAns);
            }//end else
        }//end for
        interAns = stack.pop();
        return interAns;
    }//end method
    
    public static void main(String[] args){
        //轉化后綴表達式
        String s = "3+(6*9)+2-6/(3-1)";
        IntoSuffixExpression is = new IntoSuffixExpression(s);
        String out = is.doTrans();
        
        //計算后綴表達式
        CalculateSuffixExpression cse = new CalculateSuffixExpression(out);
        long result = cse.calculateValue();
        System.out.println(result);
        
    }
    
}