LeetCode 20. 有效的括号

最新推荐文章于 2025-07-05 21:02:14 发布

jkstdio.h

最新推荐文章于 2025-07-05 21:02:14 发布

阅读量121

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode

本文链接：https://blog.youkuaiyun.com/kai73/article/details/83651972

LeetCode 专栏收录该内容

14 篇文章

订阅专栏

本文介绍了一种使用递归和栈结构的有效方法来判断字符串中的括号是否正确配对和闭合，包括圆括号、方括号和花括号。通过两个递归示例和一个高效栈解决方案，详细解释了算法的实现过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

20. 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。

示例 1:

输入: "()" 输出: true

示例 2:

输入: "()[]{}" 输出: true

示例 3:

输入: "(]" 输出: false

示例 4:

输入: "([)]" 输出: false

示例 5:

输入: "{[]}" 输出: true

您是否在真实的面试环节中遇到过这道题目呢？

使用思路：

找到第一个左括号对应的右括号后，把其中包括的内容作为子串进行递归。把右括号：

思路1：继续查找匹配的括号，寻找可以递归的子串。

思路2：右边的整体作为另一个子串继续递归。

我的解答1(递归思路)：

class Solution {
public:
    bool isValid(string s) {
        int i,c,head;
        for(int i=0;i<s.size();i++)
        {
            switch(s[i])
            {
                case '(':
                    c=0;
                    c++;
                    i++;
                    head=i;
                    while(i<s.size())
                    {
                        if('('==s[i]){c++;}
                        else if(')'==s[i]){c--;}
                        else{/*NULL*/}
                        if(0==c)
                        {
                            if(!isValid(s.substr(head,i-head))){return false;}
                            break;
                        }
                        i++;
                    }
                    if(0!=c){return false;}
                    break;
                case '[':
                    c=0;
                    c++;
                    i++;
                    head=i;
                    while(i<s.size())
                    {
                        if('['==s[i]){c++;}
                        else if(']'==s[i]){c--;}
                        else{/*NULL*/}
                        if(0==c)
                        {
                            if(!isValid(s.substr(head,i-head))){return false;}
                            break;
                        }
                        i++;
                    }
                    if(0!=c){return false;}
                    break;
                case '{':
                    c=0;
                    c++;
                    i++;
                    head=i;
                    while(i<s.size())
                    {
                        if('{'==s[i]){c++;}
                        else if('}'==s[i]){c--;}
                        else{/*NULL*/}
                        if(0==c)
                        {
                            if(!isValid(s.substr(head,i-head))){return false;}
                            break;
                        }
                        i++;
                    }
                    if(0!=c){return false;}
                    break;
                default:return false;
            }
        }
        return true;
    }
};

提交记录

76 / 76 个通过测试用例	状态：通过
执行用时：36 ms

该解答用时较长，不值得学习。

我的解答2(递归思路)：

class Solution {
public:
    bool isValid(string s) {
        int i,c,head;
        int len = s.size();
        char tmpc,tmpcp;
        for(int i=0;i<len;i++)
        {
            switch(s[i])
            {
                case '(':
                case '[':
                case '{':
                    tmpc = s[i];
                    switch(tmpc)
                    {
                        case '(':tmpcp=')';break;
                        case '[':tmpcp=']';break;
                        case '{':tmpcp='}';break;
                        default:break;
                    }
                    c=0;
                    c++;
                    i++;
                    head=i;
                    while(i<len)
                    {
                        if(tmpc==s[i]){c++;}
                        else if(tmpcp==s[i]){c--;}
                        if(0==c)
                        {
                            if(!isValid(s.substr(head,i-head))){return false;}
                            else{
                                if(i+1<len-1)
                                {
                                    if(!isValid(s.substr(i+1,len-i-1))){return false;}
                                    else{return true;}
                                }else
                                {
                                    if(i+1==len){return true;}
                                    else{return false;}
                                }
                            }
                        }
                        i++;
                    }
                    if(0!=c){return false;}
                    break;
                default:return false;
            }
        }
        return true;
    }
};

提交记录

76 / 76 个通过测试用例	状态：通过
执行用时：36 ms

该解答用时较长，不值得学习。

在此贴一个用时最短的答案：

class Solution {
public:
    bool isValid(string s) {
        char comp;
        stack<char> bracket;
        string::size_type index = 0;
        while (index != s.size())
        {
            if (s[index] == '{' || s[index] == '[' || s[index] == '(')
            {
                bracket.push(s[index]);
                ++index;
            }
            else
            {
                if (!bracket.empty())                                                           {
                    switch (bracket.top())
                    {
                        case '(': comp = ')'; break;
                        case '[': comp = ']'; break;
                        case '{': comp = '}'; break;
                    }
                    if (comp == s[index])
                        bracket.pop();
                    else
                        return false;
                }
                else
                    return false;
                ++index;
            }
        }
        return (bracket.empty()) ? true : false;
    }
};