布尔表达式

题目链接：http://noi.openjudge.cn/ch0303/6263/

总时间限制: 1000ms    内存限制: 65536kB

描述

输入一个布尔表达式，请你输出它的真假值。 比如：( V | V ) & F & ( F | V ) 
V表示true，F表示false，&表示与，|表示或，!表示非。 
上式的结果是F

输入

输入包含多行，每行一个布尔表达式，表达式中可以有空格，总长度不超过1000

输出

对每行输入，如果表达式为真，输出"V",否则出来"F"

样例输入

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

样例输出

F
V
V

分析：（来源：http://blog.csdn.net/INCINCIBLE/article/details/51151222?locationNum=5&fps=1）

原理很简单，将中缀表达式转化为前缀表达式在计算，只是代码实现比较麻烦。

中缀转前缀的步骤如下：

(1) 首先构造一个运算符栈(也可放置括号)，运算符(以括号分界点)在栈内遵循越往栈顶优先级不降低的原则进行排列。

(2)从右至左扫描中缀表达式，从右边第一个字符开始判断：

如果当前字符是数字，则分析到数字串的结尾并将数字串直接输出。

如果是运算符，则比较优先级。如果当前运算符的优先级大于等于栈顶运算符的优先级(当栈顶是括号时，直接入栈)，则将运算符直接入栈；否则将栈顶运算符出栈并输出，直到当前运算符的优先级大于等于栈顶运算符的优先级(当栈顶是括号时，直接入栈)，再将当前运算符入栈。

如果是括号，则根据括号的方向进行处理。如果是右括号，则直接入栈；否则，遇左括号前将所有的运算符全部出栈并输出，遇右括号后将左右的两括号一起删除。

(3) 重复上述操作(2)直至扫描结束，将栈内剩余运算符全部出栈并输出，再逆缀输出字符串。中缀表达式也就转换为前缀表达式了。

 

右括号有最高的优先级，左括号优先级最低。

代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<stack>
#include<cstring>
using namespace std;
char calculate(char x, char y,char oper )// 计算 x oper y 
{
    bool a=(x=='V'),b=(y=='V'),ans;
    if(oper=='|') ans=(a||b);
    else if(oper=='&') ans=(a&&b);
    return ans?'V':'F';
}
char reverse(char x) //将逻辑值取反。其实就是‘！’运算符 
{
    if(x=='V')return 'F';
    return 'V';
}
int main()
{
    string in;
    int i,j,len;
    
    while(getline(cin,in))
    {
        stack<char> Oper,num; //oper保存运算符，num保存运算结果 
        queue<char> s;        //s就是前缀表达式 
        len=in.length();
        i=len;
        in=" "+in;
        while(i>0)// 从右往左，中缀表达式转前缀表达式 
        {
            if(in[i]==' ')
            {
                i--;continue;
            }
            else if(isalpha(in[i])) s.push(in[i--]);//isalpha()函数：如果参数是字母字符，函数返回非零值，否则返回零值
            else if(in[i]=='!')  s.push(in[i--]);    //最高级的运算，直接进入表达式(这里主要是因为！运算符是单目运算符) 
            else
            {
                if(in[i]=='&'||in[i]=='|'||in[i]==')')  //低级运算，进栈 
                    Oper.push(in[i--]);
                else if(in[i]=='(')  //一个括号结束，弹出中间的所有运算符 
                {  
                    while(Oper.top()!=')')
                    {
                        s.push(Oper.top());
                        Oper.pop();
                    }
                    Oper.pop();
                    i--;
                }
            }
        }
        while(!Oper.empty())  //栈中剩下的运算符 
            s.push(Oper.top()),Oper.pop();
        
        while(!s.empty())  //计算前缀表达式 
        {       
            char ch=s.front(); s.pop();
            if(isalpha(ch))  num.push(ch);
            else Oper.push(ch);
            if(!num.empty()&&!Oper.empty()&&Oper.top()=='!')  //单目运算符‘！’；
            {   
                char x=num.top();
                num.pop();Oper.pop();
                num.push(reverse(x));
            }
            else if(num.size()>=2&&!Oper.empty())  //双目运算符 
            {
                char oper=Oper.top(),x,y;
                Oper.pop();
                x=num.top();num.pop();
                y=num.top();num.pop();
                num.push(calculate(x,y,oper));
            }
        }
        cout<<num.top()<<endl;
    }
}

 

另外，可以参考http://www.ithao123.cn/content-10400535.html

 第二种思路，递归求解。

代码来源：北大郭炜老师MOOC课程的代码。可以参考中缀表达式计算这篇文章的分析。

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

char wholeExp[1500];//表示整个表达式的字符串 
int ptr = 0;

bool exp();//读入一个表达式并返回其值 
bool item();//读入一个项并返回其值 
bool factor();//读入一个因子并返回其值 
bool notExp();//将表达式取反的操作
/*
表达式：由单独的"项"或者"项"与"|"运算符连接形成；
项：由单独的"因子"或"因子"和&运算符连接而成；
因子：可以是单独的V或F，也可以是用括号括起来的"表达式"。
*/
int main()
{
    freopen("6263.in","r",stdin);
    int t = 1;//表示第t个测试样例 
    char c;
    int i = 0;
    int n = EOF + 1;
    while(n != EOF) 
    {
        n = scanf("%c",&c);
        if( n == EOF || c == '\n') 
        {
            wholeExp[i] = '\0';
            if( i > 0) 
            {
                ptr = 0;
                bool res = exp();
                if (res) { printf("Expression %d: V\n",t++); }
                else printf("Expression %d: F\n",t++);
                /*if (res) { printf("V\n",t++); }
                else printf("F\n",t++);*/
            }
            i = 0;
        }
        else if( c != ' ') wholeExp[i++] = c;
    }
    return 0;
}

bool exp() //读入一个表达式并返回其值 
{
    bool result = item();
    while(wholeExp[ptr] == '|' ) 
    {
        ++ptr;
        result = result | item();//注意：这里的或运算不能用C语言逻辑或运算符，因为逻辑或运算符在编译器处理完以后有短路特性，可能会忽略后面的输入。比如(V|V)&F，若是用逻辑或，可能只扫描到第一个V就返回逻辑真，不再继续往后扫描了。但是其实应该是逻辑假。
    }
    return result;
}

bool item() //读入一个项并返回其值  
{
    bool result = factor();
    while(wholeExp[ptr] == '&') 
    {
        ++ptr;
        result = result & factor();//同样地，这个地方不能用逻辑与运算符，否则会错忽略后面应该扫描的东西从而返回错误的结果。比如(F&V)|V。
    }
    return result;
}

bool factor() //读入一个因子并返回其值 
{
    bool result;
    switch( wholeExp[ptr]) 
    {
        case 'F':
            ++ptr;
            return false;
            break;
        case 'V':
            ++ptr;
            return true;
            break;
        case '(':
            ++ptr;
            result = exp();
            ++ptr; //skip ')'
            return result;
            break;
        case '!':
            result = notExp();
            return result;
            break;
    }
}

bool notExp() //将表达式取反的操作
{
    //wholeExp[ptr] == '!' when called;
    ptr++;
    bool result;
    switch(wholeExp[ptr]) 
    {
        case 'F':
            ++ptr;
            return true;
            break;
        case 'V':
            ++ptr;
            return false;
            break;
        case '(':
            ++ptr;
            result = exp();
            ++ptr; //skip ')'
            return !result;
            break;
        case '!':
            result = notExp();
            return !result;
            break;
    }
}