【LeetCode】20、有效的括号，map和stack

问题描述

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

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

解题思路

有效的括号，有先进后出的思想，栈的思想，每个括号有对应的回括号，且顺序不能乱，先写的括号则后写回括号，后写的括号则先写回括号。
那么就将字符串中的字符遍历，遇到括号则入栈，遇到回括号则出栈比较，如果回括号与括号相对应则继续，如果不对应则直接返回false程序结束。遍历所有字符结束后，如果栈中为空则正确true，如果栈不为空（说明还有未与回括号对应的括号）则错误false。

核心函数代码

bool check(string str)
{
    stack<char> char_st;

    //如果string长度为奇数，则非有效括号
    if(str.size()%2==1)
    {
        return false;
    }

    for(char ch:str)
    {
        if(ch=='('||ch=='{'||ch=='[')
        {
            char_st.push(ch);
        }else if(ch==')'||ch=='}'||ch==']'){
            //如果到这一步，栈为空，返回false
            if(char_st.empty())
            {
                return false;
            }
            //出栈一个元素并判断
            char tmp = char_st.top();
            char_st.pop();
            //比较两个 括号字符是否对应，括号是否与回括号对应
            if(map(ch,tmp)){
                continue;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }

    return char_st.empty();
}

完整代码

#include<iostream>
#include<string>
#include<stack>
using namespace std;

bool check(string str);
bool map(char c1,char c2);
int main()
{
    string str;
      
    bool flag = true;

    cout<<"Please Input String: "<<endl;
    cin>>str;

    flag = check(str);
    if(flag){
        cout<<str<<"----->有效的括号"<<endl;
    }else{
        cout<<str<<"----->无效的括号"<<endl;
    }

    return 0;
}

bool check(string str)
{
    stack<char> char_st;

    //如果string长度为奇数，则非有效括号
    if(str.size()%2==1)
    {
        return false;
    }

    for(char ch:str)
    {
        if(ch=='('||ch=='{'||ch=='[')
        {
            char_st.push(ch);
        }else if(ch==')'||ch=='}'||ch==']'){
            //如果到这一步，栈为空，返回false
            if(char_st.empty())
            {
                return false;
            }
            //出栈一个元素并判断
            char tmp = char_st.top();
            char_st.pop();
            //比较两个 括号字符是否对应，括号是否与回括号对应
            if(map(ch,tmp)){
                continue;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }

    return char_st.empty();
}

bool map(char c1,char c2)
{
    bool flag = false;
    if((c1=='('&&c2==')')||(c1==')'&&c2=='(')){
        flag = true;
    }else if((c1=='{'&&c2=='}')||(c1=='}'&&c2=='{')){
        flag = true;
    }else if((c1=='['&&c2==']')||(c1==']'&&c2=='[')){
        flag = true;
    }else{
        flag = false;
    }
    return flag;
}

官方解答

方法一：栈
判断括号的有效性可以使用「栈」这一数据结构来解决。

我们对给定的字符串 ss 进行遍历，当我们遇到一个左括号时，我们会期望在后续的遍历中，有一个相同类型的右括号将其闭合。由于后遇到的左括号要先闭合，因此我们可以将这个左括号放入栈顶。

当我们遇到一个右括号时，我们需要将一个相同类型的左括号闭合。此时，我们可以取出栈顶的左括号并判断它们是否是相同类型的括号。如果不是相同的类型，或者栈中并没有左括号，那么字符串 ss 无效，返回 \text{False}False。为了快速判断括号的类型，我们可以使用哈希映射（HashMap）存储每一种括号。哈希映射的键为右括号，值为相同类型的左括号。

在遍历结束后，如果栈中没有左括号，说明我们将字符串 ss 中的所有左括号闭合，返回 \text{True}True，否则返回 \text{False}False。

注意到有效字符串的长度一定为偶数，因此如果字符串的长度为奇数，我们可以直接返回 \text{False}False，省去后续的遍历判断过程。

链接：https://leetcode-cn.com/problems/valid-parentheses/solution/you-xiao-de-gua-hao-by-leetcode-solution/
来源：力扣（LeetCode）

官方代码

class Solution {
public:
    bool isValid(string s) {
        int n = s.size();
        if (n % 2 == 1) {
            return false;
        }

        unordered_map<char, char> pairs = {
            {')', '('},
            {']', '['},
            {'}', '{'}
        };
        stack<char> stk;
        for (char ch: s) {
            if (pairs.count(ch)) //如果map的key中有 ch，也就是如果ch 为右括号
                if (stk.empty() || stk.top() != pairs[ch]) {//栈为空，说明可能是类似 “()}”的字符串。或者栈顶不等于 ch 对应的 value ，类似于 “(]” 字符串。以上两种都为假  
                    return false;
                }
                //否则为真，出栈顶元素，将左括号弹出
                stk.pop();
            }
            else {
            	//map的key中没有ch，说明ch是左括号，入栈
                stk.push(ch);
            }
        }
        //遍历完所有ch，栈不空为假，类似 “{([]” 字符串
        return stk.empty();
    }
};

复杂度分析

• 时间复杂度：O(n)O(n)，其中 nn 是字符串 ss 的长度。

• 空间复杂度：O(n + |\Sigma|)O(n+∣Σ∣)，其中 \SigmaΣ 表示字符集，本题中字符串只包含 66 种括号，|\Sigma| = 6∣Σ∣=6。栈中的字符数量为 O(n)O(n)，而哈希映射使用的空间为 O(|\Sigma|)O(∣Σ∣)，相加即可得到总空间复杂度。