栈题目：删除最外层的括号

题目

标题和出处

标题：删除最外层的括号

出处：1021. 删除最外层的括号

难度

3 级

题目描述

要求

有效括号字符串为空 $\text{""}$、$\text{"(" + A + ")"}$ 或 $\text{A + B}$ ，其中 $\text{A}$ 和 $\text{B}$ 都是有效的括号字符串，$\text{+}$ 代表字符串的连接。

• 例如，$\text{""}$，$\text{"()"}$，$\text{"(())()"}$ 和 $\text{"(()(()))"}$ 都是有效的括号字符串。

如果有效字符串 $\text{s}$ 非空，且不存在将其拆分为 $\text{s = A + B}$ 的方法，我们称其为原语，其中 $\text{A}$ 和 $\text{B}$ 都是非空有效括号字符串。

给出一个非空有效字符串 $\text{s}$，考虑将其进行原语化分解，使得：${\text{s = P}}_{\text{1}}{\text{ + P}}_{\text{2}}{\text{ + …+ P}}_{\text{k}}$，其中 ${\text{P}}_{\text{i}}$ 是有效括号字符串原语。

对 $\text{s}$ 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 $\text{s}$。

示例

示例 1：

输入：$\text{s = "(()())(())"}$
输出：$\text{"()()()"}$
解释：输入字符串为 $\text{"(()())(())"}$，原语化分解得到 $\text{"(()())" + "(())"}$，删除每个部分中的最外层括号后得到 $\text{"()()" + "()" = "()()()"}$。

示例 2：

输入：$\text{s = "(()())(())(()(()))"}$
输出：$\text{"()()()()(())"}$
解释：输入字符串为 $\text{"(()())(())(()(()))"}$，原语化分解得到 $\text{"(()())" + "(())" + "(()(()))"}$，删除每个部分中的最外层括号后得到 $\text{"()()" + "()" + "()(())" = "()()()()(())"}$。

示例 3：

输入：$\text{s = "()()"}$
输出：$\text{""}$
解释：输入字符串为 $\text{"()()"}$，原语化分解得到 $\text{"()" + "()"}$，删除每个部分中的最外层括号后得到 $\text{"" + "" = ""}$。

数据范围

• $\text{1}\le \text{s.length}\le {\text{10}}^{\text{5}}$
• $\text{s[i]}$ 为 $\text{‘(’}$ 或 $\text{‘)’}$
• $\text{s}$ 是一个有效括号字符串

解法一

思路和算法

根据题目描述，给定的字符串 $s$ 是有效括号字符串。在有效括号字符串中，左括号和右括号的数量相同且形成配对，因此最外层的括号也是左括号和右括号配对。

可以使用栈存储左括号，根据栈是否为空判断括号是否为最外层的括号。

从左到右遍历字符串 $s$，遇到左括号则将左括号入栈，遇到右括号则将栈顶的左括号出栈，表示当前的右括号和栈顶的左括号配对。对于左括号，如果入栈之前栈为空，则该左括号为最外层的括号；对于右括号，如果将栈顶的左括号出栈之后栈为空，则该右括号为最外层的括号。

根据上述规则，只需要遍历字符串一次，对于每个字符可以在 $O(1)$ 的时间内判断该字符是否为最外层的括号。将不是最外层的括号的字符拼接到结果字符串，最终得到的结果字符串即为删除最外层的括号之后的结果。

实现方面，对于字符 $c$，依次执行以下操作，等价于上述规则：

1. 判断 $c$ 是否是右括号，如果是右括号，则将栈顶的左括号出栈；

2. 如果栈不为空，则 $c$ 不是最外层的括号，将 $c$ 拼接到结果字符串；

3. 判断 $c$ 是否是左括号，如果是左括号，则将 $c$ 入栈。

代码

class Solution {
    public String removeOuterParentheses(String s) {
        StringBuffer sb = new StringBuffer();
        Deque<Character> stack = new ArrayDeque<Character>();
        int length = s.length();
        for (int i = 0; i < length; i++) {
            char c = s.charAt(i);
            if (c == ')') {
                stack.pop();
            }
            if (!stack.isEmpty()) {
                sb.append(c);
            }
            if (c == '(') {
                stack.push(c);
            }
        }
        return sb.toString();
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是字符串 $s$ 的长度。需要遍历字符串 $s$ 一次，每次入栈、出栈和拼接字符串的时间都是 $O(1)$。

• 空间复杂度：$O(n)$，其中 $n$ 是字符串 $s$ 的长度。空间复杂度主要取决于栈空间和额外创建的 $\text{StringBuffer}$ 或 $\text{StringBuilder}$ 类型的对象，空间复杂度是 $O(n)$。

解法二

思路和算法

也可以不用栈，而是使用计数的方式删除最外层的括号。

具体做法是，使用 $\text{level}$ 记录当前括号所在层数，初始时 $\text{level}=0$。遍历字符串 $s$，遇到左括号则将 $\text{level}$ 加 $1$，遇到右括号则将 $\text{level}$ 减 $1$。对于左括号，如果将 $\text{level}$ 的值加 $1$ 之前栈为空，则该左括号为最外层的括号；对于右括号，如果将 $\text{level}$ 的值减 $1$ 之后栈为空，则该右括号为最外层的括号。

根据上述规则，只需要遍历字符串一次，对于每个字符可以在 $O(1)$ 的时间内判断该字符是否为最外层的括号。将不是最外层的括号的字符拼接到结果字符串，最终得到的结果字符串即为删除最外层的括号之后的结果。

实现方面，对于字符 $c$，依次执行以下操作，等价于上述规则：

1. 判断 $c$ 是否是右括号，如果是右括号，则将 $\text{level}$ 的值减 $1$；

2. 如果 $\text{level}>0$，则 $c$ 不是最外层的括号，将 $c$ 拼接到结果字符串；

3. 判断 $c$ 是否是左括号，如果是左括号，则将 $\text{level}$ 的值加 $1$。

代码

class Solution {
    public String removeOuterParentheses(String s) {
        StringBuffer sb = new StringBuffer();
        int level = 0;
        int length = s.length();
        for (int i = 0; i < length; i++) {
            char c = s.charAt(i);
            if (c == ')') {
                level--;
            }
            if (level > 0) {
                sb.append(c);
            }
            if (c == '(') {
                level++;
            }
        }
        return sb.toString();
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是字符串 $s$ 的长度。需要遍历字符串 $s$ 一次，每次更新计数和拼接字符串的时间都是 $O(1)$。

• 空间复杂度：$O(n)$，其中 $n$ 是字符串 $s$ 的长度。需要额外创建一个长度为 $n$ 的 $\text{StringBuffer}$ 或 $\text{StringBuilder}$ 类型的对象。由于 Java 中的 $\text{String}$ 类型的对象不可变，因此空间复杂度至少为 $O(n)$。