有效的括号

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

有效字符串需满足：

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

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

示例 1:

输入: "()"
输出: true

示例 2:

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

示例 3:

输入: "(]"
输出: false

示例 4:

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

示例 5:

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

怎么说呢，这道题耗费了自己一早上时间，可能是思路不清，当时最终自己还是做出来了，虽然耗费时间很长，但是不步一个脚印嘛，继续努力哈！

自己的思路：

首先，自己先定义一个字典，这个字典每一个key是每种括号的闭口，每一个value是括号的开口。根据栈，将字符串的最后一个元素弹出，赋给一个新的数组l，然后这个元素在作为key 在字典中查值，将对应的value存入一个新的数组ll，在一个循环里面，每次在给数组赋值的时候，判断数组l的值是否与数组ll前一个值相等，如果相等，就将这两个值弹出，依次比较，如果出现错误，在字典中找不到相应的值，就取0，在最后判断数组l的长度，如果数组长度不为空，则返回False，否则返回True

举个栗子：

例：()[{}]

先声名字典：s_dict = {'}':'{',')':'(',']':'['}

然后将字符串的进入循环，将最后一个元素弹出并保存到数组L  ，在字典中将该元素作为key查找相应的value，并将对应的value存入另一个数组LL。在数组LL不为空的情况下，每一次循环都判断数组L中的当前元素和数组LL中的当前元素（LL在这个时候并没有追加，其实也就是上一个元素）是否相等，如果相等，则弹出数组L当前元素和数组L的上一个元素还有数组LL的当前元素。如果不想等，就对数组LL进行追加，如果字典中找不到相应的元素，就将追加 0 。

最后判断数组L的长度，来返回真假值。

先贴代码：

class Solution:
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        l = list()
        ll = list()
        s_len = len(s)
        if s_len == 0:
            return True
        if s_len % 2 != 0:
            return False
        s_dict = {'}':'{',')':'(',']':'['}
        for i in range(s_len-1,-1,-1):
            l.append(s[i])
            
            if len(ll)!= 0:
                if s[i] == ll[len(l)-2]:
                    l.pop()
                    l.pop(len(l)-1)
                    ll.pop()
                else:
                    ll.append(s_dict.get(s[i],"0"))
            else:
                ll.append(s_dict.get(s[i],"0"))
        return len(l)==0

这里有几点小知识点作为回忆：

1.range()的用法range (开始位置，结束位置，跳跃间隔)  这里需要注意的是结束位置，解释位置一般要比你实际的偏移一位

2.字典中实现switch和case语句，可使用get()方法。get（key,"查不到key可以取的值"）

后面我们再来看看大神的代码：

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

这是官方贴出来的题解，方法简单，代码量少！！！

思路我和差不多，但是代码是我的简化版，真的是值得学习！很明显python功底我还差的很远，路漫漫其修远兮，继续加油！