牛客题解 | 有效括号序列

原创已于 2025-03-05 09:58:36 修改 · 906 阅读

14 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #力扣 #面试 #算法力扣

于 2025-03-05 09:58:05 首次发布

牛客面试必刷101题单题解专栏收录该内容

103 篇文章

订阅专栏

题目## 题目

题目链接

题目主要信息:

给定一个只包含大中小左右括号的字符串，判断其中括号是否合法
大中小括号的数学顺序与合法无关，只需要每种左括号在右边有相应匹配的右括号即可，不可交叉匹配，应该是括号嵌套

举一反三：

学习完本题的思路你可以解决如下题目：

BM49. 表达式求值

方法：栈（推荐使用）

知识点：栈

栈是一种仅支持在表尾进行插入和删除操作的线性表，这一端被称为栈顶，另一端被称为栈底。元素入栈指的是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；元素出栈指的是从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

思路：

括号的匹配规则应该符合先进后出原理：最外层的括号即最早出现的左括号，也对应最晚出现的右括号，即先进后出，因此可以使用同样先进后出的栈：遇到左括号就将相应匹配的右括号加入栈中，后续如果是合法的，右括号来的顺序就是栈中弹出的顺序。

具体做法：

step 1：创建辅助栈，遍历字符串。
step 2：每次遇到小括号的左括号、中括号的左括号、大括号的左括号，就将其对应的呦括号加入栈中，期待在后续遇到。
step 3：如果没有遇到左括号但是栈为空，说明直接遇到了右括号，不合法。
step 4：其他情况下，如果遇到右括号，刚好会与栈顶元素相同，弹出栈顶元素继续遍历。
step 5：理论上，只要括号是匹配的，栈中元素最后是为空的，因此检查栈是否为空即可最后判断是否合法。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

import java.util.*;
public class Solution {
    public boolean isValid (String s) {
        //辅助栈
        Stack<Character> st = new Stack<Character>(); 
        //遍历字符串
        for(int i = 0; i < s.length(); i++){ 
            //遇到左小括号
            if(s.charAt(i) == '(') 
                //期待遇到右小括号
                st.push(')'); 
            //遇到左中括号
            else if(s.charAt(i) == '[') 
                //期待遇到右中括号
                st.push(']'); 
            //遇到左打括号
            else if(s.charAt(i) == '{') 
                //期待遇到右打括号
                st.push('}'); 
            //必须有左括号的情况下才能遇到右括号
            else if(st.isEmpty() || st.pop() != s.charAt(i)) 
                return false;
        }
        //栈中是否还有元素
        return st.isEmpty(); 
    }
}

C++实现代码：

class Solution {
public:
    bool isValid(string s) {
        //辅助栈
        stack<char> st; 
        //遍历字符串
        for(int i = 0; i < s.length(); i++){ 
            //遇到左小括号
            if(s[i] == '(') 
                //期待遇到右小括号
                st.push(')'); 
            //遇到左中括号
            else if(s[i] == '[') 
                //期待遇到右中括号
                st.push(']'); 
            //遇到左打括号
            else if(s[i] == '{')
                //期待遇到右打括号 
                st.push('}'); 
            //必须有左括号的情况下才能遇到右括号
            else if(st.empty()) 
                return false;
            //右括号匹配则弹出
            else if(st.top() == s[i]) 
                st.pop();
        }
        //栈中是否还有元素
        return st.empty(); 
    }
};

Python代码实现：

class Solution:
    def isValid(self , s: str) -> bool:
        #辅助栈
        st = [] 
        #遍历字符串
        for i, char in enumerate(s): 
            #遇到左小括号
            if char == '(': 
                #期待遇到右小括号
                st.append(')') 
            #遇到左中括号
            elif char == '[': 
                #期待遇到右中括号
                st.append(']') 
            #遇到左打括号
            elif char == '{': 
                #期待遇到右打括号
                st.append('}') 
            #必须有左括号的情况下才能遇到右括号
            elif(len(st) == 0): 
                return False
            #右括号匹配则弹出
            elif(st[-1] == char): 
                st.pop()
        #栈中是否还有元素
        return len(st) == 0

复杂度分析：

时间复杂度： $O (n)$ ，其中 $n$ 为字符串长度，遍历整个字符串
空间复杂度： $O (n)$ ，最坏情况下栈空间中记录整个字符串长度的右括号

题目链接

题目主要信息：

一个长度为 $n$ 的仅包含左右括号的字符串
计算最长的格式正确的括号子串的长度

举一反三：

学习完本题的思路你可以解决如下题目：

方法一：栈（推荐使用）

知识点：栈

思路：

因为括号需要一一匹配，而且先来的左括号，只能匹配后面的右括号，因此可以考虑使用栈的先进后出功能，使括号匹配。

具体做法：

step 1：可以使用栈来记录左括号下标。
step 2：遍历字符串，左括号入栈，每次遇到右括号则弹出左括号的下标。
step 3：然后长度则更新为当前下标与栈顶下标的距离。
step 4：遇到不符合的括号，可能会使栈为空，因此需要使用start记录上一次结束的位置，这样用当前下标减去start即可获取长度，即得到子串。
step 5：循环中最后维护子串长度最大值。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

import java.util.*;
public class Solution {
    public int longestValidParentheses (String s) {
        int res = 0;
        //记录上一次连续括号结束的位置
        int start = -1; 
        Stack<Integer> st = new Stack<Integer>();
        for(int i = 0; i < s.length(); i++){
            //左括号入栈
            if(s.charAt(i) == '(') 
                st.push(i);
            //右括号
            else{ 
                //如果右括号时栈为空，不合法，设置为结束位置
                if(st.isEmpty()) 
                    start = i;
                else{
                    //弹出左括号
                    st.pop(); 
                    //栈中还有左括号，说明右括号不够，减去栈顶位置就是长度
                    if(!st.empty()) 
                        res = Math.max(res, i - st.peek());
                    //栈中没有括号，说明左右括号行号，减去上一次结束的位置就是长度
                    else 
                        res = Math.max(res, i - start);
                }
            }
        }
        return res;
    }
}

C++实现代码：

class Solution {
public:
    int longestValidParentheses(string s) {
        int res = 0;
        //记录上一次连续括号结束的位置
        int start = -1; 
        stack<int> st;
        for(int i = 0; i < s.length(); i++){
            //左括号入栈
            if(s[i] == '(') 
                st.push(i);
            //右括号
            else{ 
                //如果右括号时栈为空，不合法，设置为结束位置
                if(st.empty()) 
                    start = i;
                else{
                    //弹出左括号
                    st.pop(); 
                    //栈中还有左括号，说明右括号不够，减去栈顶位置就是长度
                    if(!st.empty()) 
                        res = max(res, i - st.top());
                    //栈中没有括号，说明左右括号行号，减去上一次结束的位置就是长度
                    else 
                        res = max(res, i - start);
                }
            }
        }
        return res;
    }
};

Python代码实现：

class Solution:
    def longestValidParentheses(self , s: str) -> int:
        res = 0
        #记录上一次连续括号结束的位置
        start = -1 
        st = []
        for i in range(len(s)):
            #左括号入栈
            if s[i] == '(': 
                st.append(i)
            #右括号
            else: 
                #如果右括号时栈为空，不合法，设置为结束位置
                if len(st) == 0: 
                    start = i
                else:
                    #弹出左括号
                    st.pop()
                    #栈中还有左括号，说明右括号不够，减去栈顶位置就是长度
                    if len(st) != 0: 
                        res = max(res, i - st[-1])
                    #栈中没有括号，说明左右括号行号，减去上一次结束的位置就是长度
                    else: 
                        res = max(res, i - start)
        return res

复杂度分析：

时间复杂度： $O (n)$ ，其中 $n$ 为字符串长度，遍历整个字符串
空间复杂度： $O (n)$ ，最坏全是左括号，栈的大小为 $n$

方法二：动态规划（扩展思路）

知识点：动态规划

动态规划算法的基本思想是：将待求解的问题分解成若干个相互联系的子问题，先求解子问题，然后从这些子问题的解得到原问题的解；对于重复出现的子问题，只在第一次遇到的时候对它进行求解，并把答案保存起来，让以后再次遇到时直接引用答案，不必重新求解。动态规划算法将问题的解决方案视为一系列决策的结果

思路：

像这种子串长度的题，一般都涉及状态转移，可以用动态规划的方式。

具体做法：

step 1：用 $d p [i]$ 表示以下标为i的字符为结束点的最长合法括号长度。
step 2：很明显知道左括号不能做结尾，因此但是左括号都是 $d p [i] = 0$ 。
step 3：我们遍历字符串，因为第一位不管是左括号还是右括号dp数组都是0，因此跳过，后续只查看右括号的情况，右括号有两种情况：
- 情况一：
如图所示，左括号隔壁是右括号，那么合法括号需要增加2，可能是这一对括号之前的基础上加，也可能这一对就是起点，因此转移公式为： $d p [i] = (i >= 2 ? d p [i - 2] : 0) + 2$
- 情况二：
如图所示，与该右括号匹配的左括号不在自己旁边，而是它前一个合法序列之前，因此通过下标减去它前一个的合法序列长度即可得到最前面匹配的左括号，因此转移公式为： $d p [i] = (i - d p [i - 1] > 1 ? d p [i - d p [i - 1] - 2] : 0) + d p [i - 1] + 2$
step 4：每次检查完维护最大值即可。

Java实现代码：

import java.util.*;
public class Solution {
    public int longestValidParentheses (String s) {
        int res = 0;
        //长度为0的串或者空串，返回0
        if(s.length() == 0 || s == null) 
            return res;
        //dp[i]表示以下标为i的字符为结束点的最长合法括号长度
        int[] dp = new int[s.length()];  
        //第一位不管是左括号还是右括号都是0，因此不用管
        for(int i = 1; i < s.length(); i++){ 
            //取到左括号记为0，有右括号才合法
            if(s.charAt(i) == ')'){ 
                //如果该右括号前一位就是左括号
                if(s.charAt(i - 1) == '(') 
                    //计数+
                    dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2; 2
                //找到这一段连续合法括号序列前第一个左括号做匹配
                else if(i - dp[i - 1] > 0 && s.charAt(i - dp[i - 1] - 1) == '(') 
                    dp[i] = (i - dp[i - 1] > 1 ? dp[i - dp[i - 1] - 2] : 0) + dp[i - 1] + 2;
            }
            //维护最大值
            res = Math.max(res, dp[i]); 
        }
        return res;
    }
}

C++实现代码：

class Solution {
public:
    int longestValidParentheses(string s) {
        int res = 0;
        //长度为0的串，返回0
        if(s.length() == 0) 
            return res;
        //dp[i]表示以下标为i的字符为结束点的最长合法括号长度
        vector<int> dp(s.length(), 0); 
        //第一位不管是左括号还是右括号都是0，因此不用管
        for(int i = 1; i < s.length(); i++){ 
            //取到左括号记为0，有右括号才合法
            if(s[i] == ')'){ 
                //如果该右括号前一位就是左括号
                if(s[i - 1] == '(') 
                    //计数+2
                    dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2; 
                //找到这一段连续合法括号序列前第一个左括号做匹配
                else if(i - dp[i - 1] > 0 && s[i - dp[i - 1] - 1] == '(') 
                    dp[i] = (i - dp[i - 1] > 1 ? dp[i - dp[i - 1] - 2] : 0) + dp[i - 1] + 2;
            }
            //维护最大值
            res = max(res, dp[i]); 
        }
        return res;
    }
};

Python代码实现：

class Solution:
    def longestValidParentheses(self , s: str) -> int:
        res = 0
        #长度为0的串，返回0
        if len(s) == 0: 
            return res
        #dp[i]表示以下标为i的字符为结束点的最长合法括号长度
        dp = [0 for i in range(len(s))] 
        #第一位不管是左括号还是右括号都是0，因此不用管
        for i in range(1, len(s)): 
            #取到左括号记为0，有右括号才合法
            if s[i] == ')': 
                #如果该右括号前一位就是左括号
                if s[i - 1] == '(': 
                    #计数+2
                    if i >= 2: 
                        dp[i] = dp[i - 2] + 2
                    else:
                        dp[i] = 2 
                #找到这一段连续合法括号序列前第一个左括号做匹配
                elif i - dp[i - 1] > 0 and s[i - dp[i - 1] - 1] == '(':
                    if i - dp[i - 1] > 1:
                        dp[i] = dp[i - dp[i - 1] - 2] + dp[i - 1] + 2
                    else:
                        dp[i] = dp[i - 1] + 2
            #维护最大值
            res = max(res, dp[i]) 
        return res

复杂度分析：