1106. 解析布尔表达式

布尔表达式 是计算结果不是 true 就是 false 的表达式。有效的表达式需遵循以下约定：

• 't'，运算结果为 true
• 'f'，运算结果为 false
• '!(subExpr)'，运算过程为对内部表达式 subExpr 进行 逻辑非（NOT）运算
• '&(subExpr1, subExpr2, ..., subExprn)'，运算过程为对 2 个或以上内部表达式 subExpr1, subExpr2, ..., subExprn 进行 逻辑与（AND）运算
• '|(subExpr1, subExpr2, ..., subExprn)'，运算过程为对 2 个或以上内部表达式 subExpr1, subExpr2, ..., subExprn 进行 逻辑或（OR）运算

给你一个以字符串形式表述的 布尔表达式 expression，返回该式的运算结果。

题目测试用例所给出的表达式均为有效的布尔表达式，遵循上述约定。

示例 1：

输入：expression = "&(|(f))"
输出：false
解释：
首先，计算 |(f) --> f ，表达式变为 "&(f)" 。
接着，计算 &(f) --> f ，表达式变为 "f" 。
最后，返回 false 。

示例 2：

输入：expression = "|(f,f,f,t)"
输出：true
解释：计算 (false OR false OR false OR true) ，结果为 true 。

示例 3：

输入：expression = "!(&(f,t))"
输出：true
解释：
首先，计算 &(f,t) --> (false AND true) --> false --> f ，表达式变为 "!(f)" 。
接着，计算 !(f) --> NOT false --> true ，返回 true 。

提示：

• 1 <= expression.length <= 2 * 10^4
• expression[i] 为 '('、')'、'&'、'|'、'!'、't'、'f' 和 ',' 之一

栈

重点是左括号，根据题意得到规律：左括号前面一定是运算符，括号里面一定是f、t和逗号。

class Solution {
    public boolean parseBoolExpr(String expression) {
        Deque<Character> stack = new ArrayDeque<Character>(); // 使用栈来处理表达式
        int n = expression.length(); // 获取表达式的长度

        for (int i = 0; i < n; i++) {
            char c = expression.charAt(i); // 获取当前字符

            // 顺序无所谓
            if (c == ',') {
                continue; // 忽略逗号
            } else if (c != ')') {
                stack.push(c); // 如果不是右括号，则将字符推入栈中，此时只能是左括号、运算符、f、t
            } else {
                // 遇到右括号时，不要把右括号入栈，只处理括号内的表达式
                int t = 0, f = 0; // 统计 't' 和 'f' 的数量
                // 左括号前面一定是运算符，括号里面一定是f、t和逗号。
                while (stack.peek() != '(') {
                    char val = stack.pop(); // 弹出栈顶元素，如果不是左括号，那一定是f、t或逗号。
                    if (val == 't') {
                        t++; // 统计 't' 的数量
                    } else {
                        f++; // 统计 'f' 的数量
                    }
                }
                
                stack.pop(); // 弹出左括号 '('
                char op = stack.pop(); // 弹出操作符
                switch (op) {
                    case '!':
                        stack.push(f == 1 ? 't' : 'f'); // 逻辑非操作符，非只能作用在一个字符上。注意要把括号内的计算结果入栈。
                        break;
                    case '&':
                        stack.push(f == 0 ? 't' : 'f'); // 逻辑与操作符
                        break;
                    case '|':
                        stack.push(t > 0 ? 't' : 'f'); // 逻辑或操作符
                        break;
                    default:
                }
            }
        }
        
        return stack.pop() == 't'; // 返回最终结果。重点。
    }
}

时间复杂度O(n)，空间复杂度O(n)