表达式求值

写了大半夜终于写完了 

整理算法如下：

——遇运算对象，直接压入OPND
——遇运算符op，与OPTR 栈顶op'比较。op'   优先级不低于op   时弹出op '，从OPDN   弹出运算对象，计算结果压入OPDN。反复至栈顶运算符优先级低于op   时将运算符op   压入OPTR
——遇左括号，直接进栈OPTR
——遇右括号，逐个弹出运算符，从OPDN  弹出运算对象，计算并将结果压入OPDN，直至把对应左括号弹出
——遇表达式结束，逐个弹出运算符并进行计算，直至处理完全部运算符
——若OPDN 只有一个元素则完成并输出，否则表达式有错。

 

代码

只支持+-*/()操作

 

20. #include<iostream>
21. #include<stdlib.h>
22. using namespace std;
23. #define OK 1
24. #define ERROR 0
25. #define MAXSIZE 50
27. typedef int Status;
28. typedef struct
29. {
30.     double array[MAXSIZE];
31.     int top;   
32.      }Stack_OPND;
34. typedef struct
35. {
36.     char array[MAXSIZE];
37.     int top;   
38.      }Stack_OPTR;
39.      
40. Status InitStack(Stack_OPND &opnd,Stack_OPTR &optr)
41. {
42.        opnd.top=0;
43.        optr.array[0]='#';
44.        optr.top=1;
45.        return OK;}
46. Status Push_OPND(double a,Stack_OPND &opnd)
47. {
48.        if(opnd.top>MAXSIZE) exit(1);
49.        opnd.array[opnd.top++]=a;
50.        return OK;}
51. Status Push_OPTR(char a,Stack_OPTR &optr)
52. {
53.        if(optr.top>MAXSIZE) exit(1);
54.        optr.array[optr.top++]=a;
55.        return OK;}
56. double Pop_OPND(Stack_OPND &opnd)
57. {
58.      return opnd.array[--opnd.top];}
59.      
60. char Pop_OPTR(Stack_OPTR &optr)
61. {
62.      return optr.array[--optr.top];}
64. char Gettop_OPTR(Stack_OPTR optr)
65. {
66.      return optr.array[--optr.top];}
68. char Precede(char a,char b)
69. {
70.      switch(a)
71.      {
72.         case '+':case '-': 
73.              if(b=='+'||b=='-') 
74.                                 return '=';
75.              else if(b=='*'||b=='/') 
76.                                 return '<';
77.         case '*':case '/':
78.               if(b=='+'||b=='-') 
79.                                  return '>';
80.              else if(b=='*'||b=='/') 
81.                                  return '='; 
82.         case '(': return '<'; 
83.         case '#': return '<';
84.         default:
85.                 exit(1);}
86.         }
88. void Caculate(Stack_OPND &opnd,char op)
89. {
90.      double a,b;
91.      a=Pop_OPND(opnd);
92.      b=Pop_OPND(opnd);
93.      switch(op)
94.      {
95.          case '+':   Push_OPND(a+b,opnd); break;
96.          case '-':   Push_OPND(a-b,opnd); break;
97.          case '*':   Push_OPND(a*b,opnd); break;   
98.          case '/':   Push_OPND(a/b,opnd);    }
99. }            
100.              
101. double EvaluateExpression(char* MyExpression)
102. {
103.       Stack_OPTR OPTR;
104.       Stack_OPND OPND;
105.       char *p=MyExpression;
106.       char t[10];
107.       int i;
108.       double d;
109.       char op;
110.       InitStack(OPND,OPTR);
111.       while(*p!='/0')
112.       if(*p>='0'&&*p<='9') 
113.            {
114.               i=0; 
115.               t[i]=*p++;
116.               while(i<9&&*p>='0'&&*p<='9'||*p=='.')
117.               t[++i]=*p++;
118.               t[i+1]='/0';
119.               if(i>9) exit(1);       
120.               d=atof(t);
121.               Push_OPND(d,OPND);}
122.      else if(*p=='+'||*p=='-'||*p=='/'||*p=='*')
123.                 {  switch(Precede(Gettop_OPTR(OPTR),*p))
124.                   {
125.                     case '=': case '>':
126.                          
127.                              op=Pop_OPTR(OPTR);
128.                              Caculate(OPND,op);
129.                              Push_OPTR(*p,OPTR);p++;break;
130.                     case '<':  
131.                          Push_OPTR(*p,OPTR);p++;break;
132.                     }}
133.      else if(*p=='(')  
134.                 {
135.                  Push_OPTR(*p,OPTR);
136.                  p++;     }
137.      else if(*p==')'){
138.           while((op=Pop_OPTR(OPTR))!='(')
139.           Caculate(OPND,op);
140.           p++;}
141.      else if(*p=='=') 
142.           {
143.           while(OPTR.top!=1)
144.           {
145.              op=Pop_OPTR(OPTR);
146.              Caculate(OPND,op);   }
147.           p++;}
148.   return OPND.array[0];
149. }
151. int main()
152. {
153.     char MyExpression[100];
154.     while(cin>>MyExpression)
155.     cout<<"The answer is:"<<EvaluateExpression(MyExpression)<<endl;
156.     return 0;}
157.                      
159.      
165. 1+1=
166. The answer is:2
167. (3+4)*2=
168. The answer is:14
169. 4*(2+3*4)=
170. The answer is:56