C++中缀表达式求值（布尔表达式）

总时间限制: 

1000ms

内存限制: 

65536kB

描述

The objective of the program you are going to produce is to evaluate boolean expressions as the one shown next: 

Expression: ( V | V ) & F & ( F | V )

where V is for True, and F is for False. The expressions may include the following operators: ! for not , & for and, | for or , the use of parenthesis for operations grouping is also allowed. 

To perform the evaluation of an expression, it will be considered the priority of the operators, the not having the highest, and the or the lowest. The program must yield V or F , as the result for each expression in the input file. 

输入

The expressions are of a variable length, although will never exceed 100 symbols. Symbols may be separated by any number of spaces or no spaces at all, therefore, the total length of an expression, as a number of characters, is unknown. 

The number of expressions in the input file is variable and will never be greater than 20. Each expression is presented in a new line, as shown below. 

输出

For each test expression, print "Expression " followed by its sequence number, ": ", and the resulting value of the corresponding test expression. Separate the output for consecutive test expressions with a new line. 

Use the same format as that shown in the sample output shown below. 

样例输入

( V | V ) & F & ( F| V)
!V | V & V & !F & (F | V ) & (!F | F | !V & V)
(F&F|V|!V&!F&!(F|F&V))

样例输出

Expression 1: F
Expression 2: V

Expression 3: V

 

#include<iostream>  
#include<cstdio>  
#include<stack>  
#include<queue>  
#include<string>  
using namespace std;

stack<char> s;
queue<char> q;  //存后缀表达式   
string c;

int f(char c) {  //求表达式的优先级  
	if (c == '(') return 4;
	if (c == '!') return 3;
	if (c == '&') return 2;
	if (c == '|') return 1;
}

int f2(char c) {  //转换F和V  ，将逻辑表达式转换为数字 
	if (c == 'F') return 0;
	else return 1;
}

void houzui() {   //求表达式对应的后缀表达式   
				  //初始化栈 
	while (s.size()) {
		s.pop();
	}
	//字符串中去手动去空格 
	for (int i = 0; i<c.size(); i++) {
		if (c[i] != ' ') {  //除去空格   
							//如果遇到逻辑表达式，直接加入到队列中，用队列来放后缀表达式 
			if (c[i] == 'F' || c[i] == 'V') q.push(c[i]);
			else if (c[i] == '!'&&s.size() && s.top() == '!') { //遇到连续两个！！抵消，直接将！出栈 
				s.pop();
			}
			else if (!s.size()) s.push(c[i]);  //如果栈为空，遇到逻辑符号直接入栈 
			else if (c[i] == ')') {           //如果是右括号，则弹出对应左括号前的所有的运算符 ，加入到队列中 
				while (s.top() != '(') {
					q.push(s.top());
					s.pop();
				}
				s.pop();
				continue;
			}
			else if (f(s.top()) == 4 || (f(c[i])>f(s.top()))) s.push(c[i]);  //左括号优先级最高，入栈后优先级最低， 
			else if (f(s.top()) != 4 && f(c[i]) <= f(s.top())) {
				q.push(s.top());
				s.pop();              //如果遇到运算符没有栈顶运算符级别高，栈顶运算符加入到队列，一直循环 
				while (s.size() && f(s.top()) != 4 && f(c[i]) <= f(s.top())) {      //弹出不低于c[i]优先级的运算   
					q.push(s.top());
					s.pop();
				}
				s.push(c[i]);  //将当前运算符加入到队列 
			}
		}
	}
	//最后将所有运算符加入到栈中 
	while (s.size()) {
		q.push(s.top());
		s.pop();
	}
}

void qiuzhi() {     //后缀表达式求值   
	bool r = 1;
	char x, y;
	while (q.size()) {
		// 如果遇到运算数，运算数入栈，队列出队 
		if (q.front() == 'V' || q.front() == 'F') {
			s.push(q.front());
			q.pop();
		}
		// 遇到运算符，弹出栈顶两个元素，进行逻辑运算，结果入栈 
		else {
			// 逻辑与运算 
			if (q.front() == '&') {
				x = s.top();
				s.pop();
				y = s.top();
				s.pop();
				r = f2(x) && f2(y);
				if (r == 1)
					s.push('V');
				else
					s.push('F');
			}
			else if (q.front() == '|') {
				// 逻辑或运算 
				x = s.top();
				s.pop();
				y = s.top();
				s.pop();
				r = f2(x) || f2(y);
				if (r == 1)
					s.push('V');
				else
					s.push('F');
			}
			else {
				// 逻辑非运算，只弹一个数 
				x = s.top();
				s.pop();
				if (f2(x) == 1)
					s.push('F');
				else
					s.push('V');
			}
			q.pop();
		}
	}
}

int main()
{
	int i = 0;
	while (getline(cin, c))
	{
		i++;
		houzui();
		qiuzhi();
		printf("Expression %d: %c\n", i, s.top());
	}
	

	
}