中缀表达式与后缀表达式

[问题描述]：如何计算一个表达式的值？

表达式的表示形式有中缀、前缀和后缀三种形式。中缀表达式就是我们平时使用的表达式，按操作符的优先级进行计算：先乘除后加减，有括号先算括号里面的。中缀表达式便于人进行计算，但不便于计算机解析。后缀表达式没有优先级，计算规则简单，因此便于计算机进行解析。先将中缀表达式转换为后缀表达式，然后再计算。

后缀表达式的计算过程为：

从左到右依次扫描输入的后缀表达式，当遇到的是

1. 操作数，直接压栈；
2. 运算符，取两个操作数进行计算，并将计算结果压栈。

 
 将中缀表达式转化为后缀表达式的过程为：
从左到右依次扫描输入的中缀表达式，当遇到的是

1. 操作数：直接输出；
2. 开括号：压栈；
3. 闭括号：
   • 若栈为空，则括号不匹配，错误；
   • 若栈不为空，将栈里的元素依次弹出，直至遇到第一个开括号；
4. 运算符：
   • 当栈顶不是开括号，且该运算符的优先级不高于栈顶元素的优先级，则不断将栈顶元素弹出并输出；
   • 将该运算符压栈。

最后，如果栈非空，则将所有元素弹出并输出。

实现代码（没有进行语法检查和错误处理）如下。为了便于后缀表达式的计算，在输出的后缀表达式中插入了空白分隔字符。

#include <iostream>
#include <stack>
using namespace std;

#define MAXLEN 100

bool isDigit(char c){
	return (c >= '0' && c <= '9') || (c == '.');
}

// 中缀转为后缀
void infix2postfix(char *infix, char *postfix){
	// preprocess(infix);
	int priority[128] = {0};
	priority['+'] = priority['-'] = 1;
	priority['*'] = priority['/'] = 2;

	stack<char> Stack;
	int i = 0, k = 0;
	char c = 0;

	for(i = 0; infix[i] != 0; i++){
		switch (infix[i]){
		   case '1': case '2': case '3': case '4': case '5':
		   case '6': case '7': case '8': case '9': case '0':
		   case '.':
			   postfix[k++] = infix[i];
			   break;
		   case '(':
			   Stack.push('(');
			   break;
		   case ')':
			   if(isDigit(postfix[k-1]))
				   postfix[k++] = ' ';
			   while((c = Stack.top()) != '('){
				   postfix[k++] = c;
				   postfix[k++] = ' ';
				   Stack.pop();
			   }
			   Stack.pop();
			   break;
		   case '+':
		   case '-':
		   case '*':
		   case '/':
			   if(isDigit(postfix[k-1]))
				   postfix[k++] = ' ';
			   while(!Stack.empty() && Stack.top() != '(' && 
				   priority[c = Stack.top()] >= priority[infix[i]]){
					   postfix[k++] = c;
					   postfix[k++] = ' ';
					   Stack.pop();
			   }
			   Stack.push(infix[i]);
			   break;
		   case ' ': case '\t':
			   break;
		   default:
			   break;
		}
	}

	while(!Stack.empty()){
		postfix[k++] = ' ';
		postfix[k++] = Stack.top();;
		Stack.pop();
	}

	postfix[k] = 0;
}

// 计算后缀表达式
double calcPostfix(char *postfix){
	stack<double> Stack;
	double a, b;
	int i = 0, k = 0;
	char num[100];

	enum InDigit{IN, OUT};
	InDigit indigit = OUT;

	for(i = 0; postfix[i]; i++){
		if(isDigit(postfix[i])){
			indigit = IN;
			num[k++] = postfix[i];
		}
		else{
			if(indigit == IN){
				num[k] = 0;
				k = 0;
				Stack.push(atof(num));
			}
			indigit = OUT;

			switch (postfix[i]){
			   case '+':
				   a = Stack.top(); Stack.pop();
				   b = Stack.top(); Stack.pop();
				   Stack.push(a + b);
				   break;
			   case '-':
				   a = Stack.top(); Stack.pop();
				   b = Stack.top(); Stack.pop();
				   Stack.push(b - a);
				   break;
			   case '*':
				   a = Stack.top(); Stack.pop();
				   b = Stack.top(); Stack.pop();
				   Stack.push(a * b);
				   break;
			   case '/':
				   a = Stack.top(); Stack.pop();
				   b = Stack.top(); Stack.pop();
				   Stack.push(b / a);
				   break;
			   default:
				   break;
			}
		}
	}

	if(indigit == IN){
		num[k] = 0;
		Stack.push(atof(num));
	}

	return Stack.top();
}

int main()
{
	char infix[MAXLEN] = "1+( (1) + (1+1)*2+3 / 4 *2-10) / 2";
	char postfix[MAXLEN] = {0};

	infix2postfix(infix, postfix);

	cout<<postfix<<endl;
	cout<<calcPostfix(postfix)<<endl;
	return 0;
}

需要注意的是，负号(-)比较特殊。与减号不同，负号是单目运算符，在转换之前需要对中缀表达式进行预处理。预处理也很容易，因此减号前面是操作数，而负号前面是一定括号或者边界，只需要在负号前面加0就可以了。