1. 介绍

表达式分为前缀、中缀、后缀。前缀表达式，也称为波兰表达式，其特点是将操作符置于操作数的前面。后缀表达式，也成为逆波兰表达式，所有操作符置于操作数的后面。波兰表达式、逆波兰表达式均是由波兰数学家Jan Łukasiewicz所提出的。中缀表达式将操作符放在操作数中间。前缀表达式和后缀表达式相对于中缀表达式最大的不同是，去掉了表示运算优先级的括号。

1.1 前缀表达式求值

求值过程中会用到栈，用以存储操作数和中间运算结果。

从右至左扫描前缀表达式，进行如下操作：

（1）若遇到操作数，则操作数入栈；

（2）若遇到二元操作符，出栈两个元素；若是一元操作符，出栈一个元素；进行操作符对应的运算，将运算结果入栈；

直至扫描完整个表达式，最后栈中只有一个元素，即为表达式的值。

1.2 后缀表达式求值

与前缀表达式求值过程基本相同，不同的是从左至右扫描表达式。

1.3 中缀表达式求值

求值方法与下面的中缀转后缀的算法有点类似。中缀表达式有括号，并且操作符有运算优先级，求值过程中会用到两个栈：opnd栈和oprt栈。opnd栈用以存储操作数或中间运算结果，oprt栈用以存储操作符或'('。

从左至右扫描中缀表达式，每扫描到一个字符，做如下处理：

（1）若是操作数，则入opnd栈。

（2）若是操作符，则将其与oprt栈顶元素相比较，

①该操作符高于栈顶元素，说明该操作符的操作对象还没被扫描到，直接将该操作符压入oprt栈。

②该操作符的优先级低于oprt栈顶元素，说明该操作符前面的式子应该先运算。将oprt栈进行出栈操作直至该操作符的优先级高于栈顶元素（或栈顶元素为'('，或栈为空）。同时，opnd也对应地进行出栈操作，如果oprt栈顶元素是二元操作符，opnd出栈两个元素；如果oprt栈顶元素是一元操作符，opnd出栈一个元素；然后，进行相应的运算，将运算结果压入opnd栈。

（3）若遇到'('，直接将其压入oprt栈。

（4）若遇到')'，说明需要对该括号内的式子进行运算；oprt栈进行出栈操作直至栈顶元素是'('，并且在出栈的过程中做对应于oprt栈顶元素的运算，如（2）中②所描述。将运算结果压入opnd栈。

扫描完中缀表达式后，oprt进行出栈操作直至栈为空，并做对应于oprt栈顶元素的运算，将运算结果压入opnd栈。最后，opnd栈的栈顶元素即为中缀表达式的值。

2. 中缀与后缀之间的转换

2.1 中缀转后缀

将中缀表达式转换为后缀表达式的经典算法是Shunting yard算法（也叫调度场算法）[3]，由Dijkstra引入，因其操作类似火车编组场而得名。为了做简单的四则运算，这里将Shunting yard算法做了部分简化。

用栈存储操作符和左括号'('。

从左至右扫描中缀表达式，按如下情况进行处理：

（1）若遇到操作数，将操作数直接输出；

（2）若遇到操作符，有以下两类情况：

①操作符的运算优先级高于栈顶元素，表明该操作符的下一个操作对象还没被扫描到（针对的是二元操作符）；将该操作符压入栈。

②操作符的运算优先级低于或等于栈顶元素，表明该操作符的两个操作对象已经输出了；进行出栈操作直至该操作符优先级高于栈顶元素（或栈顶元素为'('，或栈为空）；然后，将该操作符压入栈。

（3）若遇到'('，直接将其压入栈；

（4）若遇到')'，表明该括号内的式子扫描完毕；进行出栈操作直至栈顶元素是'('，并且出栈的过程中输出栈顶元素（相当于打印括号内的操作符）。

当扫描到中缀表达式的结尾时，将栈中元素出栈并输出。所得到的输出结果为所转化的后缀表达式。

2. 2 后缀转中缀

以操作符为非叶节点、操作数为叶节点的二叉树，可以用来表示表达式，并且其前序、中序、后序遍历分别为该表达式的前缀、中缀、后缀表示法。表达式，无论是前缀、中缀或是后缀，可以确定唯一一棵与之对应的二叉树。这里，操作符均指二元：'+'，'-'，'*'，'/'。由此易知，每一个操作符有左子树和右子树。我们称左子树所对应的表达式（字符串的形式）为该操作符的左子串，与此相应地有右子串。

在中序遍历该二叉树时，遇到操作符时，对其子串是否加括号是一个非常棘手的问题，大概分四种情况考虑：

①若是'+'，其左右子串均不需加括号。

②若是'-'，仅需考虑其右子串是否加括号。如果右子串的根结点是'+'或'-'（也就是说右子串根结点的运算优先级与'-'的相等），则需加括号；若是'*'或'/'，则不需要加括号。

③若是'*'，需考虑左右子串是否加括号。如果右子串的根结点是'+'或'-'（也就是说左子串根结点的运算优先级小于'*'），则需加括号；若是'*'或'/'，则不需要加括号。同样地，对左子串的进行一样的处理。

④若是'/'，需考虑左右子串是否加括号。如果右子串的根结点是操作符，说明右子串是含有操作符的表达式，则需加括号。对左子串的处理方式与③相同，如果左子串的根结点是'+'或'-'（也就是说左子串根结点的运算优先级小于'/'），则需加括号；若是'*'或'/'，则不需要加括号。

所谓对子串加括号，是指在子串的末和尾分别加上'('和')'。

将后缀转中缀有两种方法：

方法一：由后缀表达式建立相应的二叉树，再对二叉树进行中序遍历，所得结果即为中缀表达式。

方法二：用栈来实现。有两个栈，一个是opnd栈，用以存储子串或操作数；另一个是oprt栈，用以存储是操作符的子串根节点，如果子串的根结点是操作数，不予存储。注意到，在扫描后缀表达式时，子串的根结点都是最后才被扫描到。所以，也可以说oprt栈存储的是子串的最后一个操作符。

从左至右扫描后缀表达式，

（1）若遇到操作数，直接入opnd栈。

（2）若遇操作符，从opnd栈取出两个子串，栈顶是该操作符的右子串，栈顶的下一个是该操作符的左子串；对oprt栈，如果左右子串含操作符（也就是子串长度大于1），栈顶是左子串的最后一个操作符，栈顶的下一个是右子串的操作符。如果子串的长度大于1，说明该子串含有操作符，oprt栈做出栈操作。

（3）按照上面提及的规则，做加括号的处理。

（4）处理之后，操作符入oprt栈；左子串+操作符+右子串，构成新的子串，入opnd栈。

3. Referrence

[1] 维基百科，波兰表示法。

[2] 维基百科，逆波兰表示法。

[3] 维基百科，Shunting yard算法。

[4]ssjhust123，中缀表达式转换为后缀表达式。

4. 问题

4.1 POJ 3295

题目大意：对波兰记法的前缀表达式，判断其是否为永真式。

有5个操作数p,q,r,s,and t，对应的取值情况有32种。为了取遍32种值，采用了网上代码的一个小技巧(i>>j)%2。

源代码：

3295

Accepted

184K

0MS

C++

1377B

2013-09-24 11:02:18

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

stack<int>st;
int val[5];
bool flag;
char str[101];

void calculate(int len)
{
	int i;
	int temp1,temp2;
	for(i=len-1;i>=0;i--)
	{
		switch(str[i])
		{
		case 'K':
			{
				temp1=st.top();
				st.pop();
				temp2=st.top();
				st.pop();
				st.push(temp1&&temp2);
				break;
			}
		case 'A':
			{
				temp1=st.top();
				st.pop();
				temp2=st.top();
				st.pop();
				st.push(temp1||temp2);
				break;
			}
		case 'N':
			{
				temp1=st.top();
				st.pop();
				st.push(!temp1);
				break;
			}
		case 'C':
			{
				temp1=st.top();
				st.pop();
				temp2=st.top();
				st.pop();
				st.push(!temp1||temp2);
				break;
			}
		case 'E':
			{
				temp1=st.top();
				st.pop();
				temp2=st.top();
				st.pop();
				st.push(temp1==temp2);
				break;
			}
		default:
			st.push(val[str[i]-'p']);
		}
	}
}

int main()
{
	int i,j,len;
	while (scanf("%s",&str)&&str[0]!='0')
	{
			len=strlen(str);
			flag=true;
			while(!st.empty())          //clear stack
				st.pop();

			for(i=0;i<32;i++)
			{
				for(j=0;j<5;j++)
					val[j]=(i>>j)%2;

				calculate(len);
				if(!st.top())
				{
					flag=false;
					break;
				}
			}

			if(flag)
				printf("tautology\n");
			else
				printf("not\n");
	}
	return 0;
}

4.2 POJ 2106

题目大意：对中缀记法的的布尔表达式进行求值。

非运算'!'是一元运算，并且具有最高运算优先级。输入有诸如："!!!F"的，需要考虑清楚。

没考虑到"!!!F"，RE了一次；还有一些情况没考虑到，WA了几次。逻辑关系一定要理清楚。

源代码：

2106

Accepted

184K

0MS

C++

1801B

2013-09-30 17:56:35

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

stack<char>oprt;
stack<int>opnd;
map<char,int>priority;

int compute(int a,int b,char op)
{
	if(op=='&')
		return a&&b;
	else if(op=='|')
		return a||b;
}

int evaluate(char *in)
{
	int i,temp1,temp2;
	while(!oprt.empty())
		oprt.pop();
	while(!opnd.empty())
		opnd.pop();
	
	int len=strlen(in);
	for(i=0;i<len;i++)
	{
		if(in[i]==' ')
			continue;
		else if(isupper(in[i]))
			opnd.push(in[i]=='V');
		else
		{
			switch(in[i])
			{
			case '&': case '|':
				while(!oprt.empty()&&oprt.top()!='('&&priority[in[i]]<=priority[oprt.top()])
				{
					temp1=opnd.top();
					opnd.pop();
					if(oprt.top()=='!')
						opnd.push((1+temp1)%2);
					else
					{
						temp2=opnd.top();
						opnd.pop();
						opnd.push(compute(temp2,oprt.top()));
					}
					oprt.pop();
				}
				oprt.push(in[i]);
				break;
			case '!': case '(':
				oprt.push(in[i]);
				break;
			case ')':
				while(oprt.top()!='(')
				{
					temp1=opnd.top();
					opnd.pop();
					if(oprt.top()=='!')
						opnd.push((1+temp1)%2);
					else
					{
						temp2=opnd.top();
						opnd.pop();
						opnd.push(compute(temp2,oprt.top()));
					}
					oprt.pop();
				}
				oprt.pop();
				break;
			}
		}
	}
	
	while(!oprt.empty())
	{
		temp1=opnd.top();
		opnd.pop();
		if(oprt.top()=='!')
			opnd.push((1+temp1)%2);
		else
		{
			temp2=opnd.top();
			opnd.pop();
			opnd.push(compute(temp2,oprt.top()));
		}
		oprt.pop();
	}
	return opnd.top();
}

int main()
{
	int count=1;
	char in[150];
	priority['|']=1; priority['&']=2; priority['!']=3;
	
	while(gets(in))
		printf("Expression %d: %c\n",count++,evaluate(in)?'V':'F');
	return 0;
}

4.3 POJ 1686

题目大意：判断两个表达式是否相等。

思路：将变量的值带入计算：0~9按0~9处理，其他变量取ASCII码值。若两个表达式的值相等，即说明两个表达式相等；反之，则否。中缀表达式求值太麻烦了，先将其转化为后缀表达式，再求值。

不过，这种方法会误判式子a+d与b+c相等。不过，好在测试数据没这么BT。

写代码时，犯了好多低级错误。还有，scanf遇到空格、回车等会停止读取，结束这一次的输入。若输入的字符串带空格、tab的话，用gets。

源代码：

1686

Accepted

188K

0MS

C++

1815B

2013-09-25 17:32:35

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

map<char,int>priority;

/*transform the infix to the postfix*/
void transform(char *str)
{
	stack<char>st1;
	int i,len;
	char temp[80];
	len=strlen(str);
	while (!st1.empty())
		st1.pop();
	
	for(i=0,j=0;i<len;i++)
	{
		if(isalnum(str[i]))
			temp[j++]=str[i];
		else
		{
			switch(str[i])	
			{
			case '+': case '-': case'*':
				while (!st1.empty()&&st1.top()!='('&&priority[str[i]]<=priority[st1.top()])
				{
					temp[j++]=st1.top();
					st1.pop();
				}
				st1.push(str[i]);
				break;
			case '(':
				st1.push(str[i]);
				break;
			case ')':
				while (st1.top()!='(')
				{
					temp[j++]=st1.top();
					st1.pop();
				}
				st1.pop();
				break;
			}
		}
	}
	while (!st1.empty())
	{
		temp[j++]=st1.top();
		st1.pop();
	}
	temp[j]='\0';
	strcpy(str,temp);
}

/*calculate the result of a postfix expression*/
int calculate(char *s,int len)
{
	int i;
	int temp1,temp2;
	stack<int>st2;
	for(i=0;i<len;i++)
	{
		
		if(isdigit(s[i]))
			st2.push(s[i]-'0');
		else if(isalpha(s[i]))
			st2.push(s[i]);
		else
		{
			temp1=st2.top();
			st2.pop();
			temp2=st2.top();
			st2.pop();	
			switch(s[i])
			{
			case '+':
				st2.push(temp1+temp2);
				break;
			case '-':
				st2.push(temp2-temp1);
				break;
			case '*':
				st2.push(temp1*temp2);
				break;
			}
		}
	}
	return st2.top();
}

int main()
{
	int N,result1,result2;
	char str1[80],str2[80];
	priority['+']=1;
	priority['-']=1;
	priority['*']=2;
    scanf("%d",&N);
	getchar();
	while (N--)
	{
		gets(str1);
		transform(str1);;
        result1=calculate(str1,strlen(str1));
		
		gets(str2);
		transform(str2);
        result2=calculate(str2,strlen(str2));
		
		if(result1==result2)
			printf("YES\n");
		else
			printf("NO\n");
	}
	return 0;
}

4. 4 POJ 1400

题目大意：对中缀表达式去除多余的括号。

现将中缀转后缀，再将后缀转中缀。

调试、思考了一个晚上，一早起来灵感迸发，写出来了。

源代码：

1400

Accepted

256K

704MS

C++

2586B

2013-09-30 09:10:0

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

stack<char>oprt;
stack<string>opnd;
map<char,int>priority;

string infix2postfix(string in)
{
	int i;
	string post="";
	while(!oprt.empty())
		oprt.pop();
	
	for(i=0;i<in.length();i++)
	{
		if(isalpha(in[i]))
			post+=in[i];
		else
		{
			switch(in[i])
			{
			case '+': case '-': case '*': case '/':
				while(!oprt.empty()&&oprt.top()!='('&&priority[in[i]]<=priority[oprt.top()])
				{
					post+=oprt.top();
					oprt.pop();
				}
				oprt.push(in[i]);
				break;
			case '(':
				oprt.push(in[i]);
				break;
			case ')':
				while(oprt.top()!='(')
				{
					post+=oprt.top();
					oprt.pop();
				}
				oprt.pop();
				break;
			}
		}
	}
	
	while(!oprt.empty())
	{
		post+=oprt.top();
		oprt.pop();
	}
	return post;
}

string postfix2infix(string post)
{
	int i;
	string temp1,temp2;
	char top_oprt,next_top;
	while(!oprt.empty())
		oprt.pop();
	while(!opnd.empty())
		opnd.pop();
	
	for(i=0;i<post.length();i++)
	{
		if(isalpha(post[i]))
		{
			temp1="";
			temp1+=post[i];
			opnd.push(temp1);
		}
		else
		{
			temp1=opnd.top();
			opnd.pop();
			temp2=opnd.top();
			opnd.pop();
			if(temp1.length()>1)
			{
				top_oprt=oprt.top();
				oprt.pop();
			}
			if(temp2.length()>1)
			{
				next_top=oprt.top();
				oprt.pop();
			}
			switch(post[i])
			{
			case '-':
				if(temp1.length()>1&&priority[top_oprt]==priority['-'])  //add parenthese
				{
					temp1.insert(0,"(");
					temp1.insert(temp1.length(),")");
				}
				break;
			case '*':
				if(temp1.length()>1&&priority[top_oprt]<priority['*'])
				{
					temp1.insert(0,")");
				}
				if(temp2.length()>1&&priority[next_top]<priority['*'])
				{					
					temp2.insert(0,"(");
					temp2.insert(temp2.length(),")");
				}
				break;
			case '/':
				if(temp1.length()>1)
				{
					temp1.insert(0,")");
				}
				if(temp2.length()>1&&priority[next_top]<priority['/'])
				{
					temp2.insert(0,")");
				}
				break;
			}
			oprt.push(post[i]);
			temp2+=post[i];
			temp2+=temp1;
			opnd.push(temp2);
		}
	}
	return opnd.top(); 
}

int main()
{
	int N;
	string in,post;
	priority['+']=priority['-']=1;
	priority['*']=priority['/']=2;
	
	cin>>N;
	while(N--)
	{
		cin>>in;
		post=infix2postfix(in);
		in=postfix2infix(post);
		cout<<in<<endl;
	}
	return 0;
}

原文链接：https://www.f2er.com/datastructure/383186.html