调用栈（1）

import java.util.Stack;

/**
 * 给你一个以字符串形式表述的 布尔表达式（boolean） expression，返回该式的运算结果。
 *
 * 有效的表达式需遵循以下约定：
 *
 * "t"，运算结果为 True
 * "f"，运算结果为 False
 * "!(expr)"，运算过程为对内部表达式 expr 进行逻辑 非的运算（NOT）
 * "&(expr1,expr2,...)"，运算过程为对 2 个或以上内部表达式 expr1, expr2, ... 进行逻辑 与的运算（AND）
 * "|(expr1,expr2,...)"，运算过程为对 2 个或以上内部表达式 expr1, expr2, ... 进行逻辑 或的运算（OR）
 *  
 *
 * 示例 1：
 *
 * 输入：expression = "!(f)"
 * 输出：true
 * 示例 2：
 *
 * 输入：expression = "|(f,t)"
 * 输出：true
 * 示例 3：
 *
 * 输入：expression = "&(t,f)"
 * 输出：false
 * 示例 4：
 *
 * 输入：expression = "|(&(t,f,t),!(t))"
 * 输出：false
 *  
 *
 * 提示：
 *
 * 1 <= expression.length <= 20000
 * expression[i] 由 {'(', ')', '&', '|', '!', 't', 'f', ','} 中的字符组成。
 * expression 是以上述形式给出的有效表达式，表示一个布尔值。
 *
 */

public class CallStack {

    public static void main(String[] args) {
        String expression = "|(&(t,f,t),!(t))";
        CallStack callStack = new CallStack();
        System.out.println(callStack.parseBoolExpr(expression));
    }

    public boolean parseBoolExpr(String expression) {
        Stack<Character> boolExpr = new Stack<>();
        int size = expression.length();
        for (int i = 0; i < size; i++) {
            char cutChar = expression.charAt(i);
            Stack<Character> tempStack = new Stack<>();

            if (cutChar == ',') {
                continue;
            }

            if (cutChar != ')') {
                boolExpr.push(cutChar);
            } else {
                while (boolExpr.peek() != '(') {
                    tempStack.push(boolExpr.pop());
                }
                boolExpr.pop();

                char oper = boolExpr.pop();
                Character tempChar = expr(tempStack, oper);
                if (tempChar == null) {
                    return false;
                }
                boolExpr.push(tempChar);
            }
        }
        return boolExpr.pop() == 't';
    }

    public Character expr(Stack<Character> tempStack, char oper) {
        if (oper == '!') {
            return tempStack.pop() == 't' ? 'f' : 't';
        }

        if (oper == '&') {
            while (!tempStack.isEmpty()) {
                if (tempStack.pop() == 'f') {
                    return 'f';
                }
            }
            return 't';
        }

        if (oper == '|') {
            while (!tempStack.isEmpty()) {
                if (tempStack.pop() == 't') {
                    return 't';
                }
            }
            return 'f';
        }
        return null;
    }
}

代码输出：
false