中缀表达式求值

描述

人们熟悉的四则运算表达式称为中缀表达式，例如(23+34*45/(5+6+7))。在程序设计语言中，可以利用堆栈的方法把中缀表达式转换成保值的后缀表达式（又称逆波兰表示法），并最终变为计算机可以直接执行的指令，得到表达式的值。
给定一个中缀表达式，编写程序，利用堆栈的方法，计算表达式的值。

输入

第一行为测试数据的组数N
接下来的N行，每行是一个中缀表达式。表达式中只含数字、四则运算符和圆括号，操作数都是正整数，数和运算符、括号之间没有空格。中缀表达式的字符串长度不超过600。

输出

对每一组测试数据输出一行，为表达式的值

解法

该问题可以转换为两个子问题：

1、将中缀表达式转换为后缀表达式

2、利用栈对后缀表达式求值

中缀表达式转后缀表达式

算法： 可以使用栈来完成中缀表达式到后缀表达式的转换

1、栈stack[]用来存储操作符，top指向栈顶，但不存储元素，top=0表示栈为空

2、从左向右遍历中缀表达式

　　a.如果遇到的是操作数num，则直接输出到后缀表达式

　　b.如果遇到的是操作符op，则有几种情况：

　　　　b.1.如果op==')'，则依次弹出栈顶直到弹出'('，但'('不输出到后缀表达式

　　　　b.2:如果op=='('，则直接入栈

　　　　b.3:如果栈为空，则直接入栈

　　　　b.4:如果op的优先级高于栈顶操作符的优先级，则入栈

　　　　b.5:如果op的优先级低于或等于栈顶操作符的优先级，则依次弹出栈顶直到op的优先级高于栈顶操作符的优先级（或栈为空），再将op入栈

3、遍历完时，如果栈仍不为空，则依次弹出栈顶直到栈为空

具体的代码如下：

 1 int mycmp(char a, char b) {

 2     if(b == '(')

 3         return 1;//左括号直接入栈

 4     else if((b == '*' || b == '/') &&(a == '+' || a == '-' || a == '('))

 5         return 1;//*、/优先级高于+、-、(，入栈

 6     else if((b == '+' || b == '-') && (a == '('))

 7         return 1;//+、-优先级高于(，入栈

 8     else

 9         return 0;

10 }

11 

12 /*中缀表达式转后缀表达式

13  中缀表达式之间无分割

14  后缀表达式操作数、操作符之间用空格分割，便于区分不同操作数*/

15 void infix_to_suffix(char* infix, char* suffix) {

16     int i, k, j=0, top=0;

17     char stack[1000];//存储运算符的栈

18 

19     for(i=0; infix[i]!='\0'; i++) {

20         if(infix[i] >= '0' && infix[i] <= '9') {

21             suffix[j++] = infix[i];//操作数则直接输出

22         } else {

23             if(i != 0 && infix[i-1] >= '0' && infix[i-1] <= '9') {

24                 suffix[j++] = ' ';//操作数后补充空格分割

25             }

26             if(infix[i] == ')') {

27                 //遇到右括号则一直弹出直到左括号，但左括号不输出

28                 while(stack[top-1] != '(') {

29                     suffix[j++] = stack[--top];

30                     suffix[j++] = ' ';

31                 }

32                 top--;

33             } else if(top == 0 || mycmp(stack[top-1], infix[i])) {

34                 //栈为空或当前操作符的优先级高于栈顶操作符，当前操作符入栈

35                 stack[top++] = infix[i];

36             } else {

37                 //当前操作符优先级等于或低于栈顶操作符则弹出栈顶

38                 while(!mycmp(stack[top-1], infix[i])) {

39                     suffix[j++] = stack[--top];

40                     suffix[j++] = ' ';

41                     if(top == 0)

42                         break;

43                 }

44                 stack[top++] = infix[i];//当前操作符入栈

45             }

46         }

47     }

48     //补充空格分割

49     if(suffix[j-1] != ' ') {

50         suffix[j++] = ' ';

51     }

52     //如果操作符栈不为空，弹出所有操作符

53     while(top != 0) {

54         suffix[j++] = stack[--top];

55         suffix[j++] = ' ';

56     }

57     suffix[j] = '\0';

58 }

 

利用栈对后缀表达式求值

算法：

1、栈stack[]用来存储操作数，top指向栈顶，但不存储元素，top=0表示栈为空，

2、从左向右依次遍历后缀表达式

　  a.如果遇到的是操作数num，则直接将num入栈，即stack[top++]=num

　  b.如果遇到的是操作符op，则取出依次取出栈顶的两个元素stack[top-2]和stack[top-1]，计算stack[top-2] op stack[top-1]的结果，并将结果入栈

3、遍历结束时，stack[top-1]即为后缀表达式求值结果

具体的C语言代码如下：

 1 /*后缀表达式求值*/

 2 int suffix_value(char* suffix) {

 3     int i, j;

 4     char op;

 5     int stack[1000];

 6     int top = 0, value = 0;

 7     for(i=0; suffix[i] != '\0'; i++) {

 8         if(suffix[i] >= '0' && suffix[i] <= '9') {

 9             value = value*10 + suffix[i] - '0';

10         } else if(suffix[i] == ' ') {

11             //操作数入栈

12             stack[top++] = value;

13             value = 0;

14         } else {

15             //根据操作符，对栈顶两个操作数进行计算并得到结果

16             switch(suffix[i]) {

17                 case '+': value = stack[top-2] + stack[top-1];break;

18                 case '-': value = stack[top-2] - stack[top-1];break;

19                 case '*': value = stack[top-2] * stack[top-1];break;

20                 case '/': value = stack[top-2] / stack[top-1];break;

21                 default: break;

22             }

23             top -= 2;

24         }

25     }

26 

27     return stack[0];

28 }

 

至此，中缀表达式求值的主程序如下：

 1 int main() {

 2     int n;

 3     char infix[1000], suffix[1000];//infix中缀表达式，suffix后缀表达式

 4     

 5     scanf("%d\n", &n);

 6     while(n--) {

 7         gets(infix);

 8         infix_to_suffix(infix, suffix);    

 9         printf("%d\n", suffix_value(suffix));

10     }

11 

12     return 0;

13 }