题目描述：

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

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

示例 1:
输入: “()”
输出: true

示例 2:
输入: “()[]{}”
输出: true

示例 3:
输入: “(]”
输出: false

示例 4:
输入: “([)]”
输出: false

示例 5:
输入: “{[]}”
输出: true

我的方法：

最初的想法是对的，用堆栈处理。处理流程如下：

1. 遍历字符串，从首个字符开始压入堆栈，然后比对堆栈最上面的字符和剩余字符串的首个字符。
2. 如果相等，堆栈弹出最上面的字符，剩余数组丢弃首个字符。
3. 如果不相等，则继续将剩余字符串压入堆栈。
4. 剩余字符串为空时，循环结束。
5. 此时若堆栈为空，则该字符串有效。
6. 否则，为无效。

该方法的效果还可以：执行用时 : 32 ms, 在Valid Parentheses的Python提交中击败了30.51% 的用户。内存消耗 : 10.8 MB, 在Valid Parentheses的Python提交中击败了2.24% 的用户。

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        stack=[]
        d={'[':0,']':0,'{':1,'}':1,'(':2,')':2}
        while s:
            # 如果相等，堆栈弹出最上面的字符，剩余数组丢弃首个字符
            if len(stack)>0 and d[stack[-1]]==d[s[0]] and stack[-1]!=s[0]:
                stack.pop()
                s=s[1:]
            # 否则，将s的首字符压入堆栈
            else:
                stack.append(s[0])
                s=s[1:]
        if stack==[]:
            return True
        else:
            return False

一点改进：

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        stack=[]
        d={'[':']',']':'[','{':'}','}':'{','(':')',')':'('}
        while s:
            # 如果相等，堆栈弹出最上面的字符，剩余数组丢弃首个字符
            if len(stack)>0 and d[stack[-1]]==s[0]:
                stack.pop()
                s=s[1:]
            # 否则，将s的首字符压入堆栈
            else:
                stack.append(s[0])
                s=s[1:]
        if stack==[]:
            return True
        else:
            return False

别人的方法：
基本的思想是一样的，也是用堆栈。具体步骤如下：

1. 用d记录右括号对应的左括号的散列表。
2. 遍历字符串s。
3. 如果当前字符c为右括号，且该右括号与堆栈stk顶端字符stk[-1]相对应，则弹出stk顶端字符。
4. 如果当前字符c为右括号，但未与stk顶端字符stk[-1]相对应，则返回false。
5. 如果当前字符c为左括号，则压入stk。
6. 遍历完成后，若stk依然为空，则s合法。否则，不合法。

这个方法较优的一点在于：在某些情况下，不必遍历完就能够判定是否合法字符串。例如：一开始就有一个右括号，则必然不合法。因此，理论上应该会运行得快一点。

class Solution:
    def isValid(self, s):

        d = {'}': '{', ']': '[', ')': '('}

        stk = [' '] # 堆栈

        for c in s:

            c2 = d.get(c, '')
            # stk[-1]也就是堆栈最上面的字符
            if stk[-1] == c2:
                stk.pop()
            # c2非空且未配对，则返回错误
            elif c2:
                return False
            # c2为空，则表明是左括号，压入堆栈
            else:
                stk.append(c)

        return len(stk) == 1