表达式计算

问题描述

　　输入一个只包含加减乖除和括号的合法表达式，求表达式的值。其中除表示整除。

输入格式

　　输入一行，包含一个表达式。

输出格式

　　输出这个表达式的值。

样例输入

1-2+3*(4-5)

样例输出

-4

数据规模和约定

　　表达式长度不超过100，表达式运算合法且运算过程都在int内进行。

这个题的思路就是先把中缀表达式转化为后缀表达式，然后用后缀表达式计算出式子的值

1.将中缀表达式转换为后缀表达式的方法：
(1) 初始化两个栈：运算符栈S1和储存中间结果的栈S2；
(2) 从左至右扫描中缀表达式；
(3) 遇到操作数时，将其压入S2，这里由于运算数可能大于10，所以如果数字后面一个符号是运算符，则将‘#’入S2栈充当分割线；
(4) 遇到运算符时有三种情况：
(4-1) 三种情况下直接入S1栈①S1为空②运算符为‘（’③运算符优先级比S1栈顶运算符的高；
(4-2)如果右括号“)”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到左括号为止，此时将这一对括号丢弃；
(4-3) 若运算符优先级小于或等于S1栈顶运算符的优先级，则依次弹出S1栈顶元素，直到运算符的优先级大于S1栈顶运算符优先级；
(6) 重复步骤(2)至(5)，直到表达式的最右边；
(7) 将S1中剩余的运算符依次弹出并压入S2；
(8) 依次弹出S2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式。

运算符优先级：（乘=除）>（加=减）>（左括号=右括号）。

例：将 1 + ( ( 23 + 34 ) * 5 ) - 6转化为中缀表达式

扫描到的元素

S2(栈底->栈顶)

S1 (栈底->栈顶)

说明

1

1

空

数字，直接入栈，下一个元素是运算符#入栈

+

1

+

S1为空，运算符直接入栈

(

1

+ (

左括号，直接入栈

(

1

+ ( (

左括号，直接入栈

2

1 # 2

+ ( (

数字，直接入栈下一个元素不是运算符

3

1 # 2 3 #

+ ( (

数字，直接入栈，下一个元素是运算符#入栈

+

1 # 2 3 #

+ ( ( +

+优先级大于S1栈顶运算符，直接入栈.

3

1 # 2 3 # 3

+ ( ( +

数字，直接入栈，下一个元素不是运算符

4

1 # 2 3 # 3 4 #

+ ( ( +

数字，直接入栈，下一个元素是运算符#入栈

)

1 # 2 3 # 3 4 # +

+ (

右括号，弹出S1运算符直至遇到左括号，将弹出的元素压入S2中，丢弃一对括号

*

1 # 2 3 # 3 4 # +

+ ( *

*优先级大于S1栈顶运算符，直接入栈.

5

1 # 2 3 # 3 4 # + 5 #

+ ( *

数字，直接入栈，下一个元素是运算符#入栈

)

1 # 2 3 # 3 4 # + 5 # *

+

右括号，弹出S1运算符直至遇到左括号，将弹出的元素压入S2中，丢弃一对括号

-

1 # 2 3 # 3 4 # + 5 # * +

 -

-与+优先级相同，因此弹出+，再压入-

6

1 # 2 3 # 3 4 # + 5 # * + 6 #

 -

数字，直接入栈，下一个元素是运算符#入栈

到达最右端

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

空

S1中剩余的运算符弹出并压入S2

所以计算结果为：1 # 2 3 # 3 4 # + 5 # * + 6 # -

2.后缀表达式计算方法：

（1）定义一个int栈S3，定义一个整形数组num用来存储大于10的数字便于计算，从左至右扫描表达式。

（2）遇到数字时：

（2-1）若数字后面一个元素不是#（数字后面只可能是#或数字）则将数字字符转化为数字存在num[ ]数组中；

（2-2）若数字后面一个元素是#，将num数组中保存的数字算出来并压入S3栈中。

（3）遇到运算符时，弹出S3栈顶的两个数，用运算符对它们做相应的计算（次顶元素 op 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果。

例如后缀表达式“1 # 2 3 # 3 4 # + 5 # * + 6 # -”：

扫描到的元素

S3(栈底->栈顶)

num[ ]（从左到右下标从0递增）

说明

1

1

1

数字，下一个元素为#故将num中算出来压入S3中

#

1

1

#,跳过，（下一次赋值从num[0]开始）

2

1

2

数字,下一个元素不为#故将元素转化为数字存入num中

3

1 23

2 3

数字,下一个元素为#故将num中算出来压入S3中

#

1 23

2 3

#,跳过

3

1 23

3 3

数字,下一个元素不为#故将元素转化为数字存入num中,注意从num[0]开始

4

1 23 34

3 4

数字,下一个元素为#故将num中算出来压入S3中

#

1 23 34

3 4

#，跳过

+

1 57

3 4

+，弹出S3栈顶两元素，进行加法计算后压入栈中

5

1 57 5

5 4

数字，下一个元素为#故将num中算出来压入S3中

#

1 57 5

5 4

#，跳过

*

1 285

5 4

*，弹出S3栈顶两元素，进行乘法计算后压入栈中

+

286

5 4

+，弹出S3栈顶两元素，进行加法计算后压入栈中

6

286 6

6 4

数字,下一个元素为#故将num中算出来压入S3中

#

286 6

6 4

#，跳过

-

280

6 4

-，弹出S3栈顶两元素，进行减法计算后压入栈中。

所以最后计算的结果为280

[cpp] view plain copy

print?

1. #include<iostream>      
2. #include<cstring>      
3. #include<stack>      
4. #include<algorithm>   
5. #include<cmath>      
6. using namespace std;      
7.       
8. stack<char> s1,s2;      
9. stack<int> s3;      
10. char ch[150]={0};//用来存表达式      
11. int num[11];//用来暂时存数字      
12.             
13. int priority(char ch)//用于比较字符优先级      
14. {      
15.     if(ch==')'||ch=='(') return 1;      
16.     if(ch=='+'||ch=='-') return 2;      
17.     if(ch=='*'||ch=='/') return 3;           
18. }      
19.            
20. int Scal(int x,int y,char ope)//两个数的运算      
21. {      
22.     if(ope=='+') return x+y;      
23.     if(ope=='-') return x-y;      
24.     if(ope=='*') return x*y;      
25.     if(ope=='/'&&y!=0) return x/y;      
26. }      
27.       
28. void Transform(int n)//将中缀表达式转化为后缀表达式      
29. {      
30.     int k=0;      
31.     for(int i=0;i<n;i++)      
32.     {      
33.         if(ch[i]>='0'&&ch[i]<='9')//当是数字的情况      
34.         {      
35.             if(i+1<n&&(ch[i+1]<'0'||ch[i+1]>'9')||i==n-1)//当是最后一个数字，或下一个元素是运算符      
36.             {      
37.                 s2.push(ch[i]);      
38.                 s2.push('#');      
39.             }      
40.             else      
41.                 s2.push(ch[i]);      
42.         }      
43.         else      
44.         {      
45.             if(s1.empty()||ch[i]=='('||priority(ch[i])>priority(s1.top()))//当是运算符，有3种情况直接入栈      
46.                 s1.push(ch[i]);                   
47.             else if(ch[i]==')')//当是右括号的情况      
48.             {      
49.                 while(s1.top()!='(')      
50.                 {      
51.                     s2.push(s1.top());        
52.                     s1.pop();      
53.                 }      
54.                 s1.pop();      
55.             }      
56.             else//当运算符优先级小于或等于S1栈顶运算符的优先级    
57.             {      
58.                 while(!s1.empty()&&priority(ch[i])<=priority(s1.top())&&s1.top()!='(')//这里还要注意两个界限      
59.                 {      
60.                     s2.push(s1.top());      
61.                     s1.pop();                 
62.                 }      
63.                 s1.push(ch[i]);       
64.             }         
65.         }      
66.       
67.     }      
68.     while(!s1.empty())//当表达式结束      
69.     {      
70.         s2.push(s1.top());      
71.         s1.pop();             
72.     }      
73.     while(!s2.empty()) //将栈内元素放回S2中      
74.     {      
75.         ch[k++]=s2.top();      
76.         s2.pop();         
77.     }      
78.     reverse(ch,ch+k);//将ch[]反向      
79.     ch[k]=0;      
80. }      
81.       
82. int Cal(int n)//后缀表达式计算      
83. {      
84.     int x,y,tmp=0,k=0;      
85.     for(int i=0;i<n;i++)      
86.     {      
87.         if(ch[i]=='#')//是#直接跳过      
88.             continue;      
89.         else if(ch[i]=='+'||ch[i]=='-'||ch[i]=='*'||ch[i]=='/')//是运算符弹出栈顶两元素计算后放回栈      
90.         {      
91.             x=s3.top();      
92.             s3.pop();      
93.             y=s3.top();      
94.             s3.pop();      
95.             x=Scal(y,x,ch[i]);      
96.             s3.push(x);      
97.         }      
98.         else//是数字字符      
99.         {      
100.             if(ch[i+1]=='#')//下一个元素是#      
101.             {      
102.                 num[k++]=ch[i]-'0';      
103.                 for(int i=0;i<k;i++)      
104.                     tmp+=(num[i]*(int)pow(10,k-i-1));      
105.                 s3.push(tmp);      
106.                 tmp=0;      
107.                 k=0;                      
108.             }      
109.             else//下一个元素不是#      
110.             {      
111.                 num[k++]=ch[i]-'0';       
112.             }         
113.         }      
114.     }      
115.     return s3.top();      
116. }      
117.       
118. int main()      
119. {      
120.     gets(ch);      
121.     Transform(strlen(ch));      
122.     cout<<Cal(strlen(ch))<<endl;      
123.     return 0;      
124. }      

#include<iostream>    #include<cstring>    #include<stack>    #include<algorithm> #include<cmath>    using namespace std;        stack<char> s1,s2;    stack<int> s3;    char ch[150]={0};//用来存表达式    int num[11];//用来暂时存数字              int priority(char ch)//用于比较字符优先级    {        if(ch==')'||ch=='(') return 1;        if(ch=='+'||ch=='-') return 2;        if(ch=='*'||ch=='/') return 3;         }             int Scal(int x,int y,char ope)//两个数的运算    {        if(ope=='+') return x+y;        if(ope=='-') return x-y;        if(ope=='*') return x*y;        if(ope=='/'&&y!=0) return x/y;    }        void Transform(int n)//将中缀表达式转化为后缀表达式    {        int k=0;        for(int i=0;i<n;i++)        {            if(ch[i]>='0'&&ch[i]<='9')//当是数字的情况            {                if(i+1<n&&(ch[i+1]<'0'||ch[i+1]>'9')||i==n-1)//当是最后一个数字，或下一个元素是运算符                {                    s2.push(ch[i]);                    s2.push('#');                }                else                    s2.push(ch[i]);            }            else            {                if(s1.empty()||ch[i]=='('||priority(ch[i])>priority(s1.top()))//当是运算符，有3种情况直接入栈                    s1.push(ch[i]);                             else if(ch[i]==')')//当是右括号的情况                {                    while(s1.top()!='(')                    {                        s2.push(s1.top());                          s1.pop();                    }                    s1.pop();                }                else//当运算符优先级小于或等于S1栈顶运算符的优先级              {                    while(!s1.empty()&&priority(ch[i])<=priority(s1.top())&&s1.top()!='(')//这里还要注意两个界限                    {                        s2.push(s1.top());                        s1.pop();                               }                    s1.push(ch[i]);                 }               }            }        while(!s1.empty())//当表达式结束        {            s2.push(s1.top());            s1.pop();               }        while(!s2.empty()) //将栈内元素放回S2中        {            ch[k++]=s2.top();            s2.pop();           }        reverse(ch,ch+k);//将ch[]反向        ch[k]=0;    }        int Cal(int n)//后缀表达式计算    {        int x,y,tmp=0,k=0;        for(int i=0;i<n;i++)        {            if(ch[i]=='#')//是#直接跳过                continue;            else if(ch[i]=='+'||ch[i]=='-'||ch[i]=='*'||ch[i]=='/')//是运算符弹出栈顶两元素计算后放回栈            {                x=s3.top();                s3.pop();                y=s3.top();                s3.pop();                x=Scal(y,x,ch[i]);                s3.push(x);            }            else//是数字字符            {                if(ch[i+1]=='#')//下一个元素是#                {                    num[k++]=ch[i]-'0';                    for(int i=0;i<k;i++)                        tmp+=(num[i]*(int)pow(10,k-i-1));                    s3.push(tmp);                    tmp=0;                    k=0;                                }                else//下一个元素不是#                {                    num[k++]=ch[i]-'0';                 }               }        }        return s3.top();    }        int main()    {        gets(ch);        Transform(strlen(ch));        cout<<Cal(strlen(ch))<<endl;        return 0;    }