LeetCode 20. Valid Parentheses(有效的括号)

原题

Given a string containing just the characters ‘(‘, ‘)’, ‘{‘, ‘}’, ‘[’ and ‘]’, determine if the input string is valid.

An input string is valid if:

1. Open brackets must be closed by the same type of brackets.
2. Open brackets must be closed in the correct order.

Note that an empty string is also considered valid.

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

有效字符串需满足：

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

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

Example1:

Input: "()"
Output: true

Example2:

Input: "()[]{}"
Output: true

Example3:

Input: "(]"
Output: false

Example4:

Input: "([)]"
Output: false

Example5:

Input: "{[]}"
Output: true

Note:

Given n n <script type="math/tex" id="MathJax-Element-2">n</script> will always be valid.
给定的 n 保证是有效的。

My Solution（错误）

class Solution:
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        if not s:
            return True
        if not int(len(s) % 2) == 0:
            return False
        little_bracket_count = mid_bracket_count = large_bracket_count = 0
        for i in range(len(s)):
            j = i + 1

            if i == 0:
                if s[i] == '(' or s[i] == '[' or s[i] == '{':
                    pass
                else:
                    return False

            if s[i] == '(' and j < len(s):
                little_bracket_count += 1
                if s[j] == '(' or s[j] == ')' or s[j] == '[' or s[j] == '{':
                    pass
                else:
                    return False
            elif s[i] == ')':
                little_bracket_count -= 1

            elif s[i] == '[' and j < len(s):
                mid_bracket_count += 1
                if s[j] == '[' or s[j] == ']' or s[j] == '(' or s[j] == '{':
                    pass
                else:
                    return False
            elif s[i] == ']':
                mid_bracket_count -= 1
            elif s[i] == '{' and j < len(s):
                large_bracket_count += 1
                if s[j] == '{' or s[j] == '[' or s[j] == '(' or s[j] == '}':
                    pass
                else:
                    return False
            elif s[i] == '}':
                large_bracket_count -= 1
            else:
                return False


            if j >= len(s):
                break

        if int(little_bracket_count % 2) == 0 and int(mid_bracket_count % 2) == 0 and int(large_bracket_count % 2) == 0:
            return True
        else:
            return False

没有考虑到 ‘[([]])’ 这种情况，而且思路过于复杂。

Reference solution

思路分析：我们得知道有效括号的特点 ，肯定都是左括号在一起 ，之后才是右括号 ，而且左右数量等同 ，从中间看来是严格对称的 ，所以最简单的思路就是从中间位置向两端对比 。这里采用另外的方法来实现判断 。

思路一 ：利用python种的replace函数将成对的可匹配括号用空字符代替 ，之后依次进行 ，若是有效的括号 ，必然经过有限次循环后 ，字符串为空 ，则最后判断字符串是否为空即可。思路简单 ，实现也很容易 ：

lass Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        n = len(s)
        # 空字符串 ，即无括号，但是也是有效的
        if n == 0:
            return True
        # 字符串长度为奇数 ，不可能匹配
        if n % 2 != 0:
            return False
        #算是做了个一个弊 ，利用python的replace剔除成对的括号    
        while '()' in s or '{}' in s or '[]' in s:
            s = s.replace('{}', '').replace('()', '').replace('[]', '')

        return s == ''

思路二：除了利用python的replace函数 ，我们知道数据结构种有一个栈的概念 ，对的 ，思路二就是利用栈的思路解决这一个问题 。其实质和思路一异曲同工 ，只不过不需要python的replace函数 ，也就是说其他语言也可以 ，具有普适性 。具体做法和思路一类似 ，即在 append 所有左括号后 ，再依次判断右括号和其左侧一个左括号是否匹配 ，若匹配则将刚 append 进 stack 的左括号 pop 出 ，如果为有效括号 ，最后所有的左括号都会从 stack 中 pop 出 ，即最后通过判断 stack 是否长度为 0 即可 。

class Solution:
    def isValid(self, s):
        stack = []
        for char in s:
            #将左括号依次append进列表
            if char in ["(","{","["]:
                stack.append(char)
            elif not stack: #这里是排除只有右括号的情况，如：‘）’
                return False
            #这里是到右括号时依次pop出成对的括号
            elif (char == ")") and (stack[len(stack)-1]=="("):
                stack.pop()
            elif (char == "}") and (stack[len(stack)-1]=="{"):
                stack.pop()
            elif (char == "]") and (stack[len(stack)-1]=="["):
                stack.pop()
            else:
                return False
        return len(stack)==0 #有效的括号时，上述代码会pop出所有字符，即长度为0

反思：

1. python里的replace操作，以及 s = s.replace(‘{}’, ”).replace(‘()’, ”).replace(‘[]’, ”)，即s.replace可以连着用；
2. python 里pop方法，将最后面的列表元素删除；