LeetCode 439. 三元表达式解析器

439. 三元表达式解析器

给定一个表示任意嵌套三元表达式的字符串 expression ，求值并返回其结果。

你可以总是假设给定的表达式是有效的，并且只包含数字， '?' ，  ':' ，  'T' 和 'F' ，其中 'T' 为真， 'F' 为假。表达式中的所有数字都是 一位 数(即在 [0,9] 范围内)。

条件表达式从右到左分组(大多数语言中都是这样)，表达式的结果总是为数字 'T' 或 'F' 。

示例 1：

输入： expression = "T?2:3"
输出： "2"
解释： 如果条件为真，结果为 2；否则，结果为 3。

示例 2：

输入： expression = "F?1:T?4:5"
输出： "4"
解释： 条件表达式自右向左结合。使用括号的话，相当于：
 "(F ? 1 : (T ? 4 : 5))" --> "(F ? 1 : 4)" --> "4"
or "(F ? 1 : (T ? 4 : 5))" --> "(T ? 4 : 5)" --> "4"

示例 3：

输入： expression = "T?T?F:5:3"
输出： "F"
解释： 条件表达式自右向左结合。使用括号的话，相当于：
"(T ? (T ? F : 5) : 3)" --> "(T ? F : 3)" --> "F"
"(T ? (T ? F : 5) : 3)" --> "(T ? F : 5)" --> "F"

提示:

• 5 <= expression.length <= 10^4
• expression 由数字, 'T', 'F', '?' 和 ':' 组成
• 保证 了表达式是一个有效的三元表达式，并且每个数字都是 一位数 

 

解法1：栈

算法实现步骤

1. 从字符串的末尾开始遍历。
2. 压入所有遇到的字符到栈中。
3. 当遇到 '?' 时：
   • 弹出栈顶的三个字符，它们分别是“假分支”，“：”和“真分支”。
   • 检查 '?' 前一个字符是 'T' 还是 'F'。
   • 根据条件，将相应的分支（'T' 对应真分支，'F' 对应假分支）压回栈顶。
4. 继续遍历直到字符串开始。
5. 栈顶的字符是最终结果。

Java版：

class Solution {
    public String parseTernary(String expression) {
        Deque<Character> stack = new ArrayDeque<>();
        int i = expression.length() - 1;
        while (i >= 0) {
            if (expression.charAt(i) == '?') {
                i--;
                char t = stack.pop();
                stack.pop();
                char f = stack.pop();
                if (expression.charAt(i) == 'T') {
                    stack.push(t);
                } else {
                    stack.push(f);
                }
            } else {
                stack.push(expression.charAt(i));
            }
            i--;
        }
        return String.valueOf(stack.pop());
    }
}

Python3版：

class Solution:
    def parseTernary(self, expression: str) -> str:
        stack = []
        i = len(expression) - 1
        while i >= 0:
            if expression[i] == '?':
                i -= 1
                t = stack.pop()
                stack.pop()
                f = stack.pop()
                if expression[i] == 'T':
                    stack.append(t)
                else:
                    stack.append(f)
            else:
                stack.append(expression[i])
            i -= 1
        return stack[-1]

复杂度分析

• 时间复杂度：O(n)，其中 n 是表达式的长度。因为每个字符只被遍历和处理一次。
• 空间复杂度：O(n)，栈最多存储 n 个字符。