20. 有效的括号

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

有效字符串需满足：

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

示例 1：

输入：s = "()"
输出：true
示例 2：

输入：s = "()[]{}"
输出：true
示例 3：

输入：s = "(]"
输出：false
示例 4：

输入：s = "([)]"
输出：false
示例 5：

输入：s = "{[]}"
输出：true
 

提示：

1 <= s.length <= 104
s 仅由括号 '()[]{}' 组成

我写：

class Solution {
public:

        

    bool isValid(string s) {

        int i = 0;
        int j = s.length() - 1;

        int judge = 0;
        for (int k = 0; k < 6; k += 2)
        {
            if (s[i] == n[k])
            {
                while (s[j] != n[k + 1]&&j>i)j--;
                if (j == i)return 0;
                else
                {
                    judge = YesOrNo(i, j, s);
                    break;
                }
            }
        }

        return judge;
    }

    bool YesOrNo(int l,int r,string s)
    {
        int judge = 0;
        if (s.empty())return 1;
        else
        {
            for (int i = 0; i < 6; i += 2)
            {
                if (s[l] == n[i])
                {
                    while (s[r] != n[i + 1] && r > l)r--;
                    if (r == l)return 0;
                    else
                    {
                        judge = YesOrNo(0, r-l-2, s.substr(l + 1, r-l-1));
                        break;
                    }
                }
            }
        }

        if (r == s.length() - 1 || judge == 0);
        else
        {
            l =r+1;
            r = s.length()-1;
            for (int i = 0; i < 6; i += 2)
            {
                if (s[l] == n[i])
                {
                    while (s[r] != n[i + 1] && r > l)r--;
                    if (r == l)return 0;
                    else
                    {
                        judge = YesOrNo(0, r - l-2, s.substr(l + 1, r-l- 1));
                    }
                }
            }
        }

        return judge;
    }
};

结果错了，呵呵。。。

答案是使用了栈，因为如果给定一个字符串，从左往右检索，先进去的左括号反而后出来，这和栈这种数据结构的特点很像

看完leetcode题解后写的：

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

        unordered_map<char, char> c1 = {
    {')','('},
    {']','['},
    {'}','{'}
        };

        stack<char> stk;
        for (char c : s)
        {
            if (c1.count(c))
            {
                if (stk.empty()||stk.top() != c1[c] )
                {
                    return false;
                }
                else stk.pop();
            }
            else
            {
                stk.push(c);
            }
        }

        //最后这里可以直接写成 return stk.empty()，因为只有栈空时括号才有效
        if (stk.empty())return true;
        return false;
    }
};