一、题目描述

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

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。
 

示例 1：

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

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

输入：s = "(]"
输出：false
 

提示：

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

二、题解

解1：普通方法（通过10%的测试用例）

class Solution:
    def isValid(self, s: str) -> bool:
        flag = 0
        l = len(s)
        for i in range(0,l,2):
            if  s[i] == '(' and s[i+1]==')':
                flag += 1
            if  s[i] == '[' and s[i+1]==']':
                flag += 1
            if  s[i] == '{' and s[i+1]=='}':
                flag += 1
        
        if flag == l//2:
            return True
        else:
            return False
      

 

 

解2：使用字典计数（通过80%的测试用例）

class Solution:
    def isValid(self, s: str) -> bool:
 
        dict = {
            "(":0,
            ")":0,
            "{":0,
            "}":0,
            "[":0,
            "]":0
        }
        for i in range(len(s)):
            dict[s[i]]+=1
        if dict["("] == dict[")"] and  dict["["] == dict["]"] and  dict["{"] == dict["}"]:
            return True
        else:
            return False
        

        

 

 

解3：使用栈数据结构的性质（通过所有测试用例）

class Solution:
    def isValid(self, s: str) -> bool:
        # 创建一个字典，其中键为右括号，值为对应的左括号
        dic = {')':'(',']':'[','}':'{'}
        # 创建一个空栈用于存储左括号
        stack = []
        # 遍历输入的字符串中的每个字符
        for i in s:
            # 如果栈不为空且当前字符是右括号
            if stack and i in dic:
                # 检查栈顶元素是否与当前字符所对应的左括号匹配
                if stack[-1] == dic[i]:
                    # 如果匹配，将栈顶的左括号出栈
                    stack.pop()
                else:
                    # 如果不匹配，返回False，表示括号无效
                    return False
            else:
                # 如果栈为空或者当前字符是左括号，将当前字符压入栈中
                stack.append(i)
        # 最后，判断栈是否为空，为空则表示括号有效，返回True，否则返回False
        return not stack

解4使用链表栈完成题解（通过100%）

当然，我可以给你提供一个使用链表实现栈的解决方案，以判断字符串是否有效。

首先，我们需要定义一个链表节点类 `Node` 来表示栈中的每个节点。每个节点包含一个值和指向下一个节点的指针。

```python
class Node:
    def __init__(self, value):
        self.value = value
        self.next = None
```

然后，我们定义链表栈类 `Stack` 来实现栈的基本操作。栈中有两个重要的属性：栈顶节点 `top` 和栈的大小 `size`。栈的大小可以帮助我们判断是否为空栈。

```python
class Stack:
    def __init__(self):
        self.top = None
        self.size = 0

    def push(self, value):
        new_node = Node(value)
        if not self.top:
            self.top = new_node
        else:
            new_node.next = self.top
            self.top = new_node
        self.size += 1

    def pop(self):
        if self.isEmpty():
            return None
        else:
            popped_value = self.top.value
            self.top = self.top.next
            self.size -= 1
            return popped_value

    def isEmpty(self):
        return self.size == 0
```

现在，我们可以使用链表栈来判断字符串的有效性。遍历字符串的每个字符，当遇到左括号时，将其入栈；当遇到右括号时，判断栈是否为空，或者栈顶的左括号与当前右括号不匹配，则返回 False。最后，检查栈是否为空，如果为空，则表示所有的括号都有效，返回 True。

```python
def isValid(s):
    stack = Stack()
    mapping = {')': '(', ']': '[', '}': '{'}
    for char in s:
        if char in ['(', '[', '{']:
            stack.push(char)
        elif char in [')', ']', '}']:
            if stack.isEmpty() or stack.pop() != mapping[char]:
                return False
    return stack.isEmpty()
```

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

class Stack:
    def __init__(self):
        self.top = None
        self.size = 0

    def push(self, value):
        new_node = Node(value)
        if not self.top:
            self.top = new_node
        else:
            new_node.next = self.top
            self.top = new_node
        self.size += 1

    def pop(self):
        if self.isEmpty():
            return None
        else:
            popped_value = self.top.value
            self.top = self.top.next
            self.size -= 1
            return popped_value

    def isEmpty(self):
        return self.size == 0

class Solution:
    def isValid(self, s: str) -> bool:
        stack = Stack()
        mapping = {')': '(', ']': '[', '}': '{'}
        for char in s:
            if char in ['(', '[', '{']:
                stack.push(char)
            elif char in [')', ']', '}']:
                if stack.isEmpty() or stack.pop() != mapping[char]:
                    return False
        return stack.isEmpty()

 

 

 三、知识点扩展

在Python中，栈可以使用以下两种方式实现：

1. 列表（List）实现栈：
   Python的内置类型列表（List）可以方便地用作栈数据结构。可以使用`append()`方法将元素添加到列表的末尾，使用`pop()`方法从列表的末尾移除元素。

   示例代码：
 

  ```python
   stack = []  # 创建一个空栈
   stack.append(1)  # 入栈操作
   stack.append(2)
   stack.append(3)
   top_element = stack.pop()  # 出栈操作，返回被弹出的元素
   print(top_element)  # 输出: 3
   ```

2. 链表（LinkedList）实现栈：
   如果想要更加灵活地实现栈，还可以使用自定义的链表结构来实现。链表实现栈的主要优点是在入栈和出栈操作中具有 O(1) 的时间复杂度。   示例代码：
 

 ```python
   class Node:
       def __init__(self, val):
           self.val = val
           self.next = None

   class Stack:
       def __init__(self):
           self.top = None

       def push(self, val):
           new_node = Node(val)
           new_node.next = self.top
           self.top = new_node

       def pop(self):
           if self.isEmpty():
               return None
           popped_val = self.top.val
           self.top = self.top.next
           return popped_val

       def isEmpty(self):
           return self.top is None

   stack = Stack()  # 创建一个空栈
   stack.push(1)  # 入栈操作
   stack.push(2)
   stack.push(3)
   top_element = stack.pop()  # 出栈操作，返回被弹出的元素
   print(top_element)  # 输出: 3
   ```

使用列表实现栈更为简单和高效，因此在Python中通常更常用。但是，当需要更多灵活性和控制时，可以选择实现自己的链表结构作为栈。

希望这个回答对你有所帮助。如果有任何进一步的问题，请随时提问。