一开始，尝试通过列出所有错误情况求解：

class Solution:
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        sl=sr=mr=ml=bl=br=snum=snum2=mnum=mnum2=bnum=bnum2=0
        for i in s:
            if i =='(':
                sl =sl+1
            if i ==')':
                sr =sr+1
            if i =='{':
                bl =bl+1   
            if i =='}':
                br =br+1
            if i =='[':
                ml =ml+1
            if i ==']':
                mr =mr+1
        if mr!=ml or br!=bl or sr!=sl:
            return False
        else:
            for i in range(len(s)):
                if s[i] ==')':
                    tmp = i
                    snum = snum+1
                    for j in range(tmp):
                        if s[j] =='(':
                            snum2 = snum2+1
                        else:
                            pass
                    if  snum == snum2:
                        pass
                    else:
                        return False
                if s[i] ==']':
                    tmp = i
                    mnum = mnum+1
                    for j in range(tmp):
                        if s[j] =='[':
                            mnum2 = mnum2+1
                        else:
                            pass
                    if  mnum == mnum2:
                        pass
                    else:
                        return False
                if s[i] =='}':
                    tmp = i
                    bnum = bnum+1
                    for j in range(tmp):
                        if s[j] =='{':
                            bnum2 = bnum2+1
                        else:
                            pass
                    if  bnum == bnum2:
                        pass
                    else:
                        return False
                else:
                    pass
           
                        
            return True

但是提交后发现，在处理”（{）}"这种结构时无法起作用，因此考虑要用递归的方法。

官方题解中，采用了栈的处理方法，关于有效括号表达式的一个有趣属性是有效表达式的子表达式也应该是有效表达式。让我们看看下面的这个想法，从整体表达式中一次删除一个较小的表达式，因为这是一个有效的表达式，我们最后剩留下一个空字符串。在表示问题的递归结构时，栈数据结构可以派上用场。我们无法真正地从内到外处理这个问题，因为我们对整体结构一无所知。但是，栈可以帮助我们递归地处理这种情况，即从外部到内部。

让我们看看使用栈作为该问题的中间数据结构的算法。

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """

        # The stack to keep track of opening brackets.
        stack = []

        # Hash map for keeping track of mappings. This keeps the code very clean.
        # Also makes adding more types of parenthesis easier
        mapping = {")": "(", "}": "{", "]": "["}

        # For every bracket in the expression.
        for char in s:

            # If the character is an closing bracket
            if char in mapping:

                # Pop the topmost element from the stack, if it is non empty
                # Otherwise assign a dummy value of '#' to the top_element variable
                top_element = stack.pop() if stack else '#'

                # The mapping for the opening bracket in our hash and the top
                # element of the stack don't match, return False
                if mapping[char] != top_element:
                    return False
            else:
                # We have an opening bracket, simply push it onto the stack.
                stack.append(char)

        # In the end, if the stack is empty, then we have a valid expression.
        # The stack won't be empty for cases like ((()
        return not stack

 

注意：

哈希表的用法

return的用法

栈的用法

算法

  1. 初始化栈 S。
  2. 一次处理表达式的每个括号。
  3. 如果遇到开括号，我们只需将其推到栈上即可。这意味着我们将稍后处理它，让我们简单地转到前面的 子表达式。
  4. 如果我们遇到一个闭括号，那么我们检查栈顶的元素。如果栈顶的元素是一个 相同类型的 左括号，那么我们将它从栈中弹出并继续处理。否则，这意味着表达式无效。
  5. 如果到最后我们剩下的栈中仍然有元素，那么这意味着表达式无效。参考链接：https://leetcode-cn.com/problems/valid-parentheses/solution/