帶括號表達式求值（數據結構與算法分析課程設計）

帶括號表達式求值

算法1：雙棧法 (2019.11)

算法描述：

（1）規定運算符優先級（詳見具體操做步驟）

（2）對輸入的字符逐一檢驗

　　（a）若是是數字字符：按位權轉化爲數值

　　（b）若是不是數字字符：將上一步的數值壓棧

　　　　i 若是是'('或符號棧爲空：將該字符壓入符號棧

　　　　ii 若是是')'或'='：將符號棧中全部符號彈出，每彈出一個符號從數據棧拿出兩個數字進行計算，計算結果壓入數據棧，直到數據棧爲空或棧頂元素爲'('爲止

　　　　iii 其餘狀況：比較當前元素與棧頂元素的優先級

　　　　　　(i) 若是當前元素優先級 > 棧頂元素優先級：將當前元素壓入符號棧

　　　　　　(ii) 若是當前元素優先級 <= 棧頂元素優先級：符號棧彈出一個符號進行運算，直到當前元素優先級 > 棧頂元素優先級

 

關鍵點提醒：

　　使用雙棧法時，如何確保表達式是從左往右計算的？這是處理當前元素與棧頂元素優先級相等關係時決定的，若是當前元素優先級小於等於棧頂，則直接進行運算，把運算結果存入數值棧。試想若是等於時不是彈棧進行運算，而是壓棧，那麼遇到優先級較小的運算符須要彈棧時，則會形成從右向左運算，這種狀況下有減法運算時會出錯（如3-4+8）

 

具體操做步驟：

規定運算符優先級：

運算符	(	+  -	x  /  %	^
優先級	0	1	2	3

（1）首先，創建數值棧、符號棧兩個棧分別存儲操做符和操做數。

（2）將數字字符轉化成數值。獲得通過預處理的字符串後，從頭至尾依次讀取單個字符。爲了將數字字符轉化成數值，咱們創建了state_sign和state_fraction兩個標誌位。一開始，將state_sign標誌位置1，表示正在讀取數字字符（數字字符還沒讀完），state_fraction標誌位置0，表示即將讀取的是一個數整數部分。若是遇到數字，而且state_fraction狀態是0，則將單個字符的數值（這裏指的是當前數字字符的ASCⅡ編碼值減去字符‘0’ ASCⅡ編碼值，下同）每次乘以10之後相加（最初d=0，0*10=0）；遇到小數點‘.’，則將state_fraction狀態置爲1，代表即將讀取的是一個數的小數部分；在此狀態下讀取數字字符，則依次將單個字符數值除以10後相加。

（3）將符號字符與符號棧頂字符優先級比較後決定是否存入符號棧。若是遇到的不是數字字符，則將state_sign置爲0，代表數字字符已經轉化成數值，能夠將其放入數值棧中。若是讀到的是‘(’，或者符號棧爲空，則將當前字符入符號棧，若是遇到的是‘)’或者‘=’，則將符號棧所有出棧，（一次彈出兩個，進行計算後存入數值棧）直到符號棧爲空，或者棧頂元素爲‘(’，若是遇到的不是上述符號而且符號棧不爲空，則將當前字符與符號棧棧頂字符優先級進行比較（根據程序須要，咱們將字符優先級定義爲上面「四.1」所示），若是當前字符優先級小於等於棧頂字符（這裏包含等因而爲了保證從左到右的運算法則），則直接兩次取出數值棧棧頂進行運算，並將運算結果存入棧頂；若是當前字符優先級大於棧頂字符，則把當前字符放入符號棧。

（4）對整個字符串執行上述操做，最終棧頂元素就是最後的計算結果。

 

代碼實現：（可處理異常；支持負數、小數、多位數運算；支持加減乘數乘方模運算功能）

#include<iostream> #include<stack> #include<string.h> #include<math.h>

using namespace std; stack<double> data; stack<char> sign; int priority(char ch){ //運算符優先級判斷 
    if(ch == '+'||ch == '-') return 1; if(ch == 'x'||ch == '/'|| ch== '%') return 2; if(ch == '^') return 3; if(ch == '(') return 0; } double aRb(char ch){ //判斷運算類型 
    double a,b; a = data.top(); data.pop(); b = data.top(); data.pop(); //依次取出棧頂兩個元素 
    switch(ch){ case '+' : b += a; break; case '-' : b -= a; break; case 'x' : b *= a; break; case '/' : if(a==0){ throw "Divider can not be zero!"; //除數爲0，拋出異常 
            }else { b /= a; break; } case '%' : if(a==0){ throw "divider can not be zero!"; //除數爲0，拋出異常
            }else { b = (double)((int)b%(int)a); break; } case '^' : b = pow(b,a); //乘方、開方運算 
            break; } return b; } int base(char temp){ //判斷字符類型 
    char base_digtal[] = {"1234567890"}; char base_sign[] = {"+-x/%^"}; char base_others[] = {"().="}; if(strchr(base_digtal,temp)) return 1; else if(strchr(base_sign,temp)) return 2; else if(strchr(base_others,temp)) return 3; else return 0; } void showerror(char temp[],int e){ //指出第一次出現錯誤的位置 
    for(int i=0;i<strlen(temp);i++){ if(i==e) cout<<temp[e]<<"<| "; else cout<<temp[i]; } cout<<endl; } bool precheck(char temp[]){ stack<char> t; for(int i=0;i<strlen(temp);i++){ if((temp[i]&0x80) && (temp[i+1]&0x80)){//若是字符高位爲1且下一字符高位也是1則有中文字符
            cout<<"請不要輸入中文字符"<<endl; showerror(temp,i+1); return false; } if(temp[i] == '='&& i!=strlen(temp)-1){ //若是等號出如今表達式中間則報錯 
            cout<<"Invalid input"<<endl; showerror(temp,i); return false; } if(!base(temp[i])){ cout<<"Please input the sign appointed！"<<endl;//出現未知符號 
 showerror(temp,i); return false; } if((temp[i]=='('||temp[i]==')')&&i!=0&&i!=strlen(temp)-1&&base(temp[i-1])==1&&base(temp[i+1])==1){ cout<<"Both sides of parenthesis are numbers!"<<endl; //符號省略 
 showerror(temp,i); return false; } if(((base(temp[0])==2)&&temp[0]!='-')||(i==strlen(temp)-1&&base(temp[i])==2)||(base(temp[i])==2&&base(temp[i+1])==2)){ cout<<"Signs redundancy!"<<endl;//符號冗餘（重複輸入） 
 showerror(temp,i); return false; } if(temp[i]=='.'&&base(temp[i+1])!=1){ cout<<"The fraction part you put is wrong!"<<endl;//小數部分輸入錯誤 
 showerror(temp,i); return false; } if(temp[i]=='(') t.push(temp[i]); if(temp[i]==')') t.pop(); } if(t.empty()) return true; else { cout<<"Parenthesis is not matching!"<<endl;//括號不匹配 
        return false; } } double calculate(char temp[]){ double d = 0; bool state_fraction = 0;//判斷當前數字字符在小數點前面仍是後面 
    bool state_sign = 1;//判斷一個數是否讀完 
    int count = 1; for(int i=0;i<strlen(temp);i++){ //把數字字符處理成數值 
        if(!state_fraction&&base(temp[i])==1){ d *= 10; d += (double)(temp[i] - '0'); state_sign=0; }else if(temp[i]=='.'){ state_fraction = 1; }else if(state_fraction&&(base(temp[i])==1)){ d += (double)(temp[i] - '0')/pow(10,count); count++; state_sign=0; }else{ if(!state_sign) { data.push(d); } d = 0; state_fraction = 0; count = 1; if(temp[i]=='('||sign.empty()){//若是是(或棧爲空直接入棧 
 sign.push(temp[i]); }else if(temp[i]==')'||temp[i]=='='){ //若是遇到)或者=，則符號棧所有出棧，同時從數值棧取出兩個數進行運算 
                while(!sign.empty()&&sign.top()!='('){//根據短路原則，注意順序 
                    double res = aRb(sign.top()); data.push(res); sign.pop(); } if(!sign.empty()) sign.pop();//彈出( 
            }else if(priority(temp[i])<=priority(sign.top())){ //若是優先級小於等於棧頂，則直接進行運算，把運算結果存入數值棧 //等號的位置決定從左到右進行運算 
                while(!sign.empty()&&priority(temp[i])<=priority(sign.top())){ double res = aRb(sign.top()); data.push(res); sign.pop(); } sign.push(temp[i]); }else if(priority(temp[i])>priority(sign.top())){ //若是優先級大於棧頂，則入符號棧 
 sign.push(temp[i]); } state_sign = 1;    //遇到非數字字符表示數字部分已讀完 
 } } return data.top(); //棧頂元素即爲最終運算結果 
} int main() { cout<<"---------Welcome!---------"<<endl; cout<<"----Input exit to exit----"<<endl; double ans; //最終計算結果 
    while(1){ char temp[300]; //存儲讀入的字符串，用於預處理等操做 
        memset(temp,0,300); while(!data.empty()) data.pop(); while(!sign.empty()) sign.pop(); //初始化
        cin.getline(temp,300); if(strcmp(temp,"exit")==0) break; //程序出口 //展現更精確的結果
        if(strcmp(temp,"show more")==0){ printf("ans = %.9lf\n",ans); continue; } //對空格進行處理
        for(int i=0;i<strlen(temp);i++){ if(temp[i]==' ') for(int k=i;k<strlen(temp);k++) temp[k] = temp[k+1]; } if(!precheck(temp)) continue; //預處理結果判斷 //對'-'前沒有數字的狀況進行加0處理 
        if(temp[0]=='-'){ int k = strlen(temp); for(k;k>0;k--) temp[k] = temp[k-1]; temp[0] = '0'; } for(int i=1;i<strlen(temp);i++){ if(temp[i]=='-'&& base(temp[i-1])!=1&&temp[i-1]!=')'){ int k = strlen(temp); for(k;k>i;k--) temp[k] = temp[k-1]; temp[i] = '0'; } } //若是用戶沒有輸入'='，在字符串末尾添加'=' 
        int k = strlen(temp); temp[k] = '\0'; if(temp[k-1]!='=') { temp[k] = '='; temp[k+1] = '\0'; } //運行異常檢測 
        try{ ans = calculate(temp); cout<<"ans = "<<ans<<endl; }catch(const char*message){ cout<<message<<endl; } } return 0; } //測試數據 //-(-3+(3x(5/2+(3^2%5)+5)x2)/3)+((2x5-3)x2)= //-(-2+3-5)= //12+.3-.5x2 //.3+4-2x(3+5/2^3)-.3 //-3.4+4 //3.22.4+2? //2.3x(3+3.4)-4/2.2 //(2-(-(-(-(-(-2)x3)x1)x.3)/2.3)-2)/2 //2.6125 + 0.04150390625

View Code

 

 

算法2：基於棧的逆波蘭算法  (201911)

算法具體步驟：

（1）創建一個操做符棧（臨時存放操做符）；再創建一個隊列（存放後綴表達式）；

再創建一個棧（後綴表達式求值時臨時存放操做數）；

後綴表達式中有數字(double)有字符(char)，後綴表達式要存放在一個棧中，能夠將隊列的基本類型定義爲結構體類型。

 

（2）將中綴表達式轉換成後綴式（逆波蘭表達式）

　　(a） 從左到右讀進中綴表達式的每一個字符。

　　(b)  若是讀到的字符爲操做數，則直接輸出到後綴表達式中（注意多位數和小數的處理參照算法1（有優化））。

　　(c）若是遇到「)」，則彈出棧內的運算符，直到彈出到一個「(」；若是遇到「=」，則彈出棧內全部運算符

　　(d） 「(」的優先級在棧內比任何運算符都小，但可直接入棧

　　(e）當運算符準備進入棧內時，和棧頂的運算符比較，若是外面的運算符優先級高於棧頂的運算符的優先級，則壓棧；若是優先級低於或等於棧頂的運算符的優先級，則彈棧到後綴表達式中。直到棧頂的運算符的優先級低於外面的運算符優先級或者棧爲空時，再把外面的運算符壓棧。

　　(f）中綴表達式讀完後，若是運算符棧不爲空，則將其內的運算符逐一彈出，輸出到後綴表達式中。

(2)而後對後綴表達式進行求值

　　(a）從頭至尾讀取表達式，若是遇到數字就壓棧。

　　(b）若是遇到運算符，彈出兩個數進行運算，將運算結果壓棧。

 

代碼實現：（爲了簡便起見，沒有處理異常；支持負數、小數、多位數運算；支持加減乘數乘方模運算功能）20200202

#include<iostream> #include<stack> #include<queue> #include<string> #include<cstring> #include<cmath>

using namespace std; typedef struct{ double num; //操做數 
    char op; //操做符
    bool flag; //true爲操做數，false爲操做符 
}node; stack<char> sign; //臨時存放操做符 
queue<node> suffix; //存放後綴表達式 
stack<double> data; //後綴表達式求值時臨時存放操做數 

int priority(char ch){ //運算符優先級判斷 //《算法筆記》中用map來映射運算符優先級 
    if(ch == '+'||ch == '-') return 1; if(ch == 'x'||ch == '/'|| ch== '%') return 2; if(ch == '^') return 3; if(ch == '(') return 0; } void aRb(char ch){ //判斷運算類型 
    double a,b; a = data.top(); data.pop(); b = data.top(); data.pop(); //依次取出棧頂兩個元素 
    switch(ch){ case '+' : b += a; break; case '-' : b -= a; break; case 'x' : b *= a; break; case '/' : if(a==0){ throw "Divider can not be zero!"; //除數爲0，拋出異常 
            }else { b /= a; break; } case '%' : if(a==0){ throw "divider can not be zero!"; //除數爲0，拋出異常
            }else { b = (double)((int)b%(int)a); break; } case '^' : b = pow(b,a); //乘方、開方運算 
            break; } data.push(b); } int base(char temp){ //判斷字符類型 
    char base_digtal[] = {"1234567890"}; char base_sign[] = {"+-x/%^"}; char base_others[] = {"().="}; if(strchr(base_digtal,temp)) return 1; else if(strchr(base_sign,temp)) return 2; else if(strchr(base_others,temp)) return 3; else return 0; } void change(string temp){ for(int i=0;i<temp.length();){ //從左到右依次讀中綴表達式
        if(base(temp[i]) == 1 || temp[i] =='.'){ //把數字字符處理成數值
            double d = 0; bool state_fraction = 0;//判斷當前數字字符在小數點前面仍是後面 
            int count = 1; while(base(temp[i]) == 1 || temp[i] =='.'){ if(!state_fraction&&base(temp[i])==1){ d *= 10; d += (double)(temp[i] - '0'); }else if(temp[i]=='.'){ state_fraction = 1; }else if(state_fraction&&(base(temp[i])==1)){ d += (double)(temp[i] - '0')/pow(10,count); count++; } i++; } node t; t.num = d; t.flag = 1; suffix.push(t); //數值入棧 
        }else{//處理非數字字符
            if((sign.empty()||temp[i] == '(') && temp[i]!='=') sign.push(temp[i]); else if(temp[i] == ')'){ while(!sign.empty() && sign.top()!='('){ node t; t.op = sign.top(); t.flag = 0; suffix.push(t); sign.pop(); } if(!sign.empty()) sign.pop(); //pop操做前都必須判斷是否爲empty 
 } else if(temp[i] == '='){ while(!sign.empty()){ node t; t.op = sign.top(); t.flag = 0; suffix.push(t); sign.pop(); } } else if(base(temp[i]) == 2){ if(priority(temp[i])<=priority(sign.top())){ while(!sign.empty()&&priority(temp[i])<=priority(sign.top())){ node t; t.op = sign.top(); t.flag = 0; suffix.push(t); sign.pop(); } } sign.push(temp[i]); } i++; } } } double calculate(){ while(!suffix.empty()){ if(suffix.front().flag == 1) { printf("%lf ",suffix.front().num); data.push(suffix.front().num); } else if(suffix.front().flag == 0){ printf("%c ",suffix.front().op); aRb(suffix.front().op); } suffix.pop(); } return data.top(); } int main() { double ans; //最終計算結果 
    while(1){ string temp; //存儲讀入的字符串，用於預處理等操做 
        while(!data.empty()) data.pop(); while(!sign.empty()) sign.pop(); //初始化
 getline(cin,temp); if(temp == "exit") break; //程序出口 
        string::iterator it = temp.end() - 1; if(*it != '=') temp.insert(it+1,'=');//若是用戶沒有輸入'='，在字符串末尾添加'=' 
        for(it = temp.begin();it!=temp.end();it++){ if(*it == ' ') temp.erase(it); //對空格進行處理；注意先檢驗空格，再進行下一步處理 
            if(it==temp.begin() && *it=='-') temp.insert(it,'0'); if(*it == '-'){ if(base(*(it-1))!=1 && *(it-1)!=')') temp.insert(it,'0'); //對'-'前沒有數字的狀況進行加0處理 
 } } cout<<temp<<endl; change(temp); ans = calculate(); cout<<endl; cout<<"ans = "<<ans<<endl; } return 0; } //測試數據 //-(-3+(3x(5/2+(3^2%5)+5)x2)/3)+((2x5-3)x2)= // - ( - 2 + 3 - 5 ) = //12+.3-.5x2 //.3+4-2x(3+5/2^3)-.3 //-3.4+4 //2.3x(3+3.4)-4/2.2 //(2-(-(-(-(-(-2)x3)x1)x.3)/2.3)-2)/2

View Code

 

 

算法3：基於二叉樹的逆波蘭算法 (20200122)

算法描述：將中綴表達式用二叉樹結構存儲。二叉樹的後序遍歷即爲後綴表達式，而後用逆波蘭算法求後綴表達式的值。

 

如何構建二叉樹？（摘自課件）

1. If the current token is a '(', add a new node as the left child of the current node, and descend to（指向） the left child.

2. If the current token is in the vector ['+','-','/','*'], set the root value of the current node to the operator represented by the current token. Add a new node as the right child of the current node and descend to the right child.

3. If the current token is a number, set the root value of the current node to the number and return to the parent.

4. If the current token is a ')', go to the parent of the current node.

 

關鍵點提醒：構造二叉樹時要注意初始化葉節點的左右孩子爲NULL

 

代碼實現：（僅支持一位數加減乘除運算，且必須帶有括號；也可對字符串進行預處理成下列代碼能運行的格式）

#include<iostream> #include<stack>

using namespace std; typedef struct BSTNode{ char value; struct BSTNode *parent; struct BSTNode *left; struct BSTNode *right; }BSTNode; BSTNode *cur = new BSTNode; int ans; stack<char> s; void aRb(char t){ char temp = s.top(); s.pop(); if(t=='+') ans = s.top() + temp; else if(t=='-') ans = s.top() - temp; else if(t=='x') ans = s.top() * temp; else if(t=='/') ans = s.top() / temp; s.pop(); s.push(ans); } void InOrder(BSTNode *T){ if(T!=NULL){ InOrder(T->left); cout<<T->value; InOrder(T->right); } } void PostOrder(BSTNode *T){ if(T!=NULL){ PostOrder(T->left); PostOrder(T->right); cout<<T->value<<" "; if(T->value>='0'&&T->value<='9') s.push(T->value - '0'); else aRb(T->value); } } int main(){ cur->parent = NULL; //賦初值很重要 
    char ch = cin.get(); while(ch != '\n'){ if(ch=='(') { cur->left = new BSTNode; cur->left->parent = cur; cur = cur->left; cur->left = NULL;//賦初值很重要 
            cur->right = NULL; } else if(ch>='0'&&ch<='9'){ cur->value = ch; cur = cur->parent; } else if(ch==')'){ if(cur->parent) cur = cur->parent; } else if(ch=='+'||'-'||'x'||'/'){ if(ch=='+') cur->value = '+'; else if(ch=='-') cur->value = '-'; else if(ch=='x') cur->value = 'x'; else if(ch=='/') cur->value = '/'; cur->right = new BSTNode; cur->right->parent = cur; cur = cur->right; cur->left = NULL;//賦初值很重要 
            cur->right = NULL; } ch = cin.get(); } cout<<"中綴表達式："; InOrder(cur); cout<<endl; cout<<"後綴表達式："; PostOrder(cur); cout<<endl; cout<<"Answer = "<<ans<<endl; return 0; } /*----Test---- //注意測試數據需嚴格按照該標準來定，不然沒法構建二叉樹 (3+(4x5)) (3-(4+(5x3))) (3-(4-(5x(3-(4+5)))) */

View Code

 

 

反思：

　　逆波蘭表達式進行一位數運算時，具備很大的優勢，但涉及到多位數與小數的運算時，它使用起來須要一點技巧。由於轉化爲後綴表達式時，須要將數值和運算符存入同一個隊列中，而若是是多位數與小數，則必須將數值轉化爲double型，而不能利用char型（一位數能夠利用char型減去'0'的ASCII碼），可是運算符是char型，這樣就致使了同一個隊列中要存入兩種類型的元素。

　　有兩種解決辦法：第一種：（思路來源於《算法筆記》P249）將隊列的基本類型定義爲結構體類型；（如上述代碼所示）

　　第二種：把運算符double化，即把運算符轉爲double型類型的數據與數值一道，存入同一個容器中，爲了不運算符的值與數值的值發生衝突，咱們必須對數值的範圍做出限制（如若咱們規定+爲99999999，那麼全部進行計算的數值必須小於99999999），這樣使得運算範圍縮小，故不推薦。