【每日一题Day18】LC1106解析布尔表达式|栈

解析布尔表达式

最新推荐文章于 2025-12-03 23:35:37 发布

原创最新推荐文章于 2025-12-03 23:35:37 发布 · 207 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #数据结构 #java

每日一题同时被 2 个专栏收录

371 篇文章

订阅专栏

栈

3 篇文章

订阅专栏

本文介绍了解析布尔表达式的两种方法，一种使用两个栈分别处理运算符和布尔值，另一种使用单个栈简化处理流程。这两种方法均能有效地计算布尔表达式的最终结果。

解析布尔表达式【LC1106】

A boolean expression is an expression that evaluates to either true or false. It can be in one of the following shapes:

't' that evaluates to true.
'f' that evaluates to false.
'!(subExpr)' that evaluates to the logical NOT of the inner expression subExpr.
'&(subExpr1, subExpr2, ..., subExprn)' that evaluates to the logical AND of the inner expressions subExpr1, subExpr2, ..., subExprn where n >= 1.
'|(subExpr1, subExpr2, ..., subExprn)' that evaluates to the logical OR of the inner expressions subExpr1, subExpr2, ..., subExprn where n >= 1.

Given a string expression that represents a boolean expression, return the evaluation of that expression.

It is guaranteed that the given expression is valid and follows the given rules.

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

有效的表达式需遵循以下约定：

"t"，运算结果为 True
"f"，运算结果为 False
"!(expr)"，运算过程为对内部表达式 expr 进行逻辑 非的运算（NOT）
"&(expr1,expr2,...)"，运算过程为对 2 个或以上内部表达式 expr1, expr2, ... 进行逻辑 与的运算（AND）
"|(expr1,expr2,...)"，运算过程为对 2 个或以上内部表达式 expr1, expr2, ... 进行逻辑 或的运算（OR）

比昨天的简单呐

两个栈

思路：
- 构建两个栈，分别存放运算符（!、&、|）以及布尔值和左括号（(、t、f），然后模拟布尔运算
- 遇到右括号时，将运算符弹出，并将左括号内的布尔值弹出，进行相应的运算，最后将该次结果保存在栈内
- 最终结果即为栈顶元素

实现

注意：与和或操作为多元运算符，需要记录上次的结果，

初始变量时：或运算初始值为假不影响最终结果，与运算初始值为真不影响最终结果

class Solution {
    public boolean parseBoolExpr(String expression) {
        Deque<Character> stTf = new LinkedList<>();
        Deque<Character> stOpera = new LinkedList<>();
        for (int i = 0; i < expression.length(); i++){
            char c = expression.charAt(i);
            if (c == ','){
                continue;
            }else if (c == '(' || c == 't' || c == 'f'){
                stTf.addFirst(c);
            }else if (c == '!' || c == '&' || c == '|' ){
                stOpera.addFirst(c);
            }else if (c == ')'){ // 进行运算
                char opera = stOpera.pollFirst();
                // 或运算初始值为假不影响结果 与运算初始值为真不影响结果
                boolean tmp = opera == '|' ? false : true;
                while (stTf.peekFirst() != '('){
                    boolean flag = stTf.pollFirst() == 't' ? true : false;
                    if (opera == '|'){
                        tmp =  tmp || flag;
                    }else if ( opera == '!'){
                        tmp =  !flag;
                    }else { 
                        tmp = tmp && flag;
                    }
                }
                stTf.pollFirst();
                stTf.addFirst(tmp ? 't' : 'f');
            }
        }
        return stTf.pollFirst() == 't' ? true : false;
    }
}

复杂度
- 时间复杂度：O(n)
- 空间复杂度：O(n)

一个栈

思路：
- 单个运算表达式的结果取决于运算符以及括号内t和f的个数，因此可以使用一个栈解决该问题
  - 如果运算符是 ‘!’，当f的个数为1时表达式的值为‘t’
  - 如果运算符是 ‘&’，当f的个数为0时表达式的值为‘t’
  - 如果运算符是 ‘|’，当t的个数大于0时表达式的值为‘t’
实现
1. 构建一个栈，存放运算符（!、&、|）以及布尔值和左括号（(、t、f），然后模拟布尔运算
2. 字符串遇到右括号时，将栈内左括号内的‘t’和‘f’弹出，并统计其个数
3. 栈内遇到左括号时，将其弹出，并记录其下一个元素【运算符】
4. 根据规律计算结果，并将其压入栈中
5. 最终结果即为栈顶元素

代码

class Solution {
    public boolean parseBoolExpr(String expression) {
        Deque<Character> st = new LinkedList<>();
        for (int i = 0; i < expression.length(); i++){
            char c = expression.charAt(i);
            if (c == ','){
                continue;
            }else if (c != ')' ){
                st.addFirst(c);
            }else { 
                // 统计t和f的个数
                int t = 0, f = 0;
                while (st.peekFirst() != '('){
                    if (st.pollFirst() == 't'){
                        t++;
                    }else{
                        f++;
                    }
                }
                st.pollFirst();
                char opera = st.pollFirst();
                // 根据运算符进行运算
                if (opera == '!'){
                    if (f == 1){
                        st.addFirst('t');
                    }else{
                        st.addFirst('f');
                    }
                }else if (opera == '&'){
                    if (f == 0){
                        st.addFirst('t');
                    }else{
                        st.addFirst('f');
                    }
                }else{
                    if (t > 0){
                        st.addFirst('t');
                    }else{
                        st.addFirst('f');
                    }
                }
            }
        }
        return st.pollFirst() == 't' ? true : false;
    }
}