表达式求值问题

           实验内容实验内容：表达式求值问题。这里限定的表达式求值问题是：用户输入一个包含“+”、“-”、“*”、“/”、正整数和圆括号的合法数学表达式，计算该表达式的运算结果。算术表达式求值过程是：STEP 1：先将算术表达式转换成后缀表达式。 STEP 2：然后对该后缀表达式求值。实验说明：在设计相关算法中用到栈，这里采用顺序栈存储结构。 中缀表达式exp ==》后缀表达式postexp伪代码如下： 对后缀表达式postexp求值伪代码如下： 实验内容一、顺序栈的基本操作定义了两个顺序栈，一种为char类型，主要适用于将前缀表达式转换为后缀表达式，另一种为double类型，用于后缀表达式求值。其中实现了栈的一些出栈入栈的基本操作，方便实现表达式转

转化和求值。

1. #include<iostream>
2. #include<string.h>
3. using namespace std;
4. #define MaxSize 100
6. typedef char ElemType;
7. typedef double ElemType1;
9. typedef struct {
10.  ElemType data[MaxSize];
11.  int top;
12. }SqStack;
14. typedef struct {
15.  ElemType1 data[MaxSize];
16.  int top;
17. }SqStack1;
19. void InitSqStack(SqStack*& s) {
20.  s = new SqStack;
21.  s->top = -1;
22. }
24. bool Push(SqStack*& s, ElemType e) {
25.  if (s->top == MaxSize - 1)
26.   return false;
27.  s->top++;
28.  s->data[s->top] = e;
29.  return true;
30. }
32. void Pop(SqStack*& s, ElemType& e) {
33.  if (s->top == -1)
34.   return;
35.  e = s->data[s->top];
36.  s->top--;
37. }
39. void InitSqStack1(SqStack1*& s) {
40.  s = new SqStack1;
41.  s->top = -1;
42. }
44. void Push1(SqStack1*& s, ElemType1 e) {
45.  if (s->top == MaxSize - 1)
46.   return;
47.  s->top++;
48.  s->data[s->top] = e;
49. }
51. void Pop1(SqStack1*& s, ElemType1& e) {
52.  if (s->top == -1)
53.   return;
54.  e=s->data[s->top];
55.  s->top--;
56. }
58. bool StackEmpty(SqStack* op) {
59.  return op->top == -1;
60. }
62. bool GetTop1(SqStack1* op, ElemType1& e) {
63.  if (op->top == -1)
64.   return false;
65.  e = op->data[op->top];
66.  return true;
67. }
69. ElemType Precede(ElemType a, ElemType b) {//a是op栈顶运算符，b是表达式的运算符。
70.  ElemType f=' ';//定义f存放返回的符号
71.  switch (b) {//表达式符号
72.  case'+':
73.   if (a == '(' || a == '=')//>表示退栈运算符，并存放入postexp
74.    f = '<';
75.   else
76.    f = '>';
77.   break;
78.  case'-':
79.   if (a == '(' || a == '=')
80.    f = '<';
81.   else
82.    f = '>';
83.   break;
84.  case'*':
85.   if (a == '(' || a == '+' || a == '-' || a == '=')//乘除的优先级比加减高
86.    f = '<';
87.   else
88.    f = '>';
89.   break;
90.  case'/':
91.   if (a == '(' || a == '+' || a == '-' || a == '=')
92.    f = '<';
93.   else
94.    f = '>';
95.   break;
96.  case'('://表示一个子表达式的开始，直接将其进栈
97.    f = '<';
98.   break;
99.  case')'://表示一个表达式的结束，需要计算表达式的值，出栈并存入postexp
100.   if (a == '(' || a == '=')
101.    f = '=';
102.   else
103.    f = '>';
104.  }
105.  return f;
106. }
108. bool GetTop(SqStack* op, ElemType& e) {
109.  if (op->top == -1)
110.   return false;
111.  e = op->data[op->top];
112.  return true;
113. }
115. void trans(char* exp, char postexp[]) {
116.  //将算术表达式exp转换成后缀表达式postexp
117.  char e;
118.  SqStack* op; //定义并初始化运算符栈op;
119.  int i=0;//作为访问postexp的下标
120.  InitSqStack(op);
121.  Push(op, '=');
122.  while (*exp != '\0') {
123.   if (*exp >= '0' && *exp <= '9') {
124.    //将后续的所有数字均依次存放到postexp中, 并以字符'#'标志数值串结束;
125.    while (*exp >= '0' && *exp <= '9') {
126.     postexp[i++] = *exp;
127.     exp++;
128.    }
129.    postexp[i++] = '#';
130.   }
131.   else
132.   switch (Precede(op->data[op->top], *exp)) {
133.   case'<'://栈顶运算符优先级低
134.    Push(op, *exp);
135.    exp++; //将ch进栈;  从exp读取下字符ch;
136.    break;
137.   case'='://只有栈顶运算符为'(',ch为')'的情况
138.    Pop(op, e);
139.    exp++;//退栈; 从exp读取下字符ch;
140.    break;
141.   case'>':
142.    //栈顶运算符应先执行,所以出栈并存放到postexp中
143.    Pop(op, e);
144.    postexp[i++] = e;//退栈运算符并将其存放到postexp中
145.    break;
146.   }
147.  }
148.  while (op->data[op->top]!='=') {
149.   //若字符串exp扫描完毕,则将运算符栈op中'='之前的所有运算符依次出栈并存放到
150.   //postexp中。最后得到后缀表达式postexp; 
151.   Pop(op, e);
152.   postexp[i++] = e;
153.  }
154.  postexp[i] = '\0';
155. }
157. ElemType1 compvalue(char* postexp) {
158.  double a, b, c, d, e;
159.  SqStack1* op;
160.  InitSqStack1(op);
161.  while (*postexp != '\0') {//postexp字符串未遍历完时循环
162.   switch (*postexp) {
163.   case'+'://若ch为“+”,则从数值栈st中退栈两个运算数,相加后进栈st中。
164.    Pop1(op, a);
165.    Pop1(op, b);
166.    c = b + a;
167.    Push1(op, c);
168.    break;
169.   case'-':// 若ch为“－”,则从数值栈st中退栈两个运算数,相减后进栈st中。
170.    Pop1(op, a);
171.    Pop1(op, b);
172.    c = b - a;
173.    Push1(op, c);
174.    break;
175.   case'*'://若ch为“*”,则从数值栈st中退栈两个运算数,相乘后进栈st中。
176.    Pop1(op, a);
177.    Pop1(op, b);
178.    c = b * a;
179.    Push1(op, c);
180.    break;
181.   case'/'://若ch为“/”,则从数值栈st中退栈两个运算数,相除后进栈st中
182.    Pop1(op, a);
183.    Pop1(op, b);
184.    if (a != 0) {//若除数为零,则提示相应的错误信息
185.     c = b / a;
186.     Push1(op, c);
187.     break;
188.    }
189.    else
190.     exit(0);
191.    break;
192.   default:
193.    d = 0;//若字符串postexp扫描完毕,则数值栈op中的栈顶元素就是表达式的值。
194.    while (*postexp >= '0' && *postexp <= '9') {
195.     d = 10 * d + *postexp - '0';
196.     postexp++;
197.    }
198.    Push1(op, d);
199.    break;
200.   }
201.   postexp++;
202.  }
203.  GetTop1(op, e);//取栈顶元素e
204.  return e;
205. }
207. int main() {
208.  char exp[MaxSize];
209.  cin >> exp;
210.  int a = strlen(exp);
211.  exp[a] = '\0';
212.  char postexp[MaxSize];
213.  trans(exp, postexp);
214.  cout << "中缀：" << exp << endl;
215.  cout << "后缀：" << postexp << endl;
216.  cout << "value:" << compvalue(postexp) << endl;
217. }