目录
栈
python实现
队列
python实现
循环队列
力扣622- --循环队列
力扣20 ----有效括号判断
分析
代码
栈
python实现
在Python中实现一个栈（Stack）可以通过使用列表（list）来完成，因为列表提供了动态数组的特性，可以方便地进行添加和删除操作。下面是一个简单的栈实现：
class Stack:
def __init__(self):
self.items = [] # 初始化一个空列表作为栈的存储结构
def is_empty(self):
"""判断栈是否为空"""
return len(self.items) == 0
def push(self, item):
"""入栈操作，将元素添加到栈顶"""
self.items.append(item)
def pop(self):
"""出栈操作，移除并返回栈顶元素"""
if self.is_empty():
raise IndexError("pop from an empty stack")
return self.items.pop()
def peek(self):
"""查看栈顶元素，不移除它"""
if self.is_empty():
raise IndexError("peek from an empty stack")
return self.items[-1]
def size(self):
"""返回栈的大小"""
return len(self.items)这个栈的实现包括以下方法：
-
__init__(self): 构造函数，初始化一个空的列表来存储栈中的元素。 -
is_empty(self): 判断栈是否为空，如果栈的大小为0，则返回True。 -
push(self, item): 入栈操作，将一个元素添加到栈顶（列表的末尾）。 -
pop(self): 出栈操作，移除并返回栈顶的元素。如果栈为空，则抛出一个IndexError异常。 -
peek(self): 查看栈顶元素，不移除它。如果栈为空，则抛出一个IndexError异常。 -
size(self): 返回栈中元素的数量，即栈的大小。
这个栈的实现简单且直观，利用了Python列表的动态特性来模拟栈的后进先出（LIFO）行为。
队列
python实现
在Python中实现队列可以使用列表（list）或双端队列（deque）。这里我将展示两种实现方式：
### 使用列表实现队列
```python
class Queue:
def __init__(self):
self.items = [] # 使用列表存储队列元素
def is_empty(self):
"""判断队列是否为空"""
return len(self.items) == 0
def enqueue(self, item):
"""入队操作，将元素添加到队列尾部"""
self.items.append(item)
def dequeue(self):
"""出队操作，移除并返回队列头部元素"""
if self.is_empty():
raise IndexError("dequeue from an empty queue")
return self.items.pop(0)
def front(self):
"""查看队列头部元素，不移除它"""
if self.is_empty():
raise IndexError("front from an empty queue")
return self.items[0]
def size(self):
"""返回队列的大小"""
return len(self.items)
```### 使用双端队列（deque）实现队列
`collections.deque` 是一个双端队列，它提供了从两端快速添加和移除元素的能力，非常适合实现队列。
```python
from collections import deque
class Queue:
def __init__(self):
self.items = deque() # 使用双端队列存储队列元素
def is_empty(self):
"""判断队列是否为空"""
return len(self.items) == 0
def enqueue(self, item):
"""入队操作，将元素添加到队列尾部"""
self.items.append(item)
def dequeue(self):
"""出队操作，移除并返回队列头部元素"""
if self.is_empty():
raise IndexError("dequeue from an empty queue")
return self.items.popleft()
def front(self):
"""查看队列头部元素，不移除它"""
if self.is_empty():
raise IndexError("front from an empty queue")
return self.items[0]
def size(self):
"""返回队列的大小"""
return len(self.items)
```
这两种实现方式的主要区别在于：
- 使用列表实现队列时，出队操作（`dequeue`）需要移动列表中的所有元素，因此时间复杂度为O(n)。
- 使用双端队列实现队列时，出队操作的时间复杂度为O(1)，因为 `popleft` 操作是高效的。
因此，推荐使用双端队列来实现队列，以获得更好的性能。
循环队列
力扣622- --循环队列
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
你的实现应该支持如下操作：
- MyCircularQueue(k): 构造器，设置队列长度为 k 。
- Front: 从队首获取元素。如果队列为空，返回 -1 。
- Rear: 获取队尾元素。如果队列为空，返回 -1 。
- enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
- deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
- isEmpty(): 检查循环队列是否为空。
- isFull(): 检查循环队列是否已满。
示例：
MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3 circularQueue.enQueue(1); // 返回 true circularQueue.enQueue(2); // 返回 true circularQueue.enQueue(3); // 返回 true circularQueue.enQueue(4); // 返回 false，队列已满 circularQueue.Rear(); // 返回 3 circularQueue.isFull(); // 返回 true circularQueue.deQueue(); // 返回 true circularQueue.enQueue(4); // 返回 true circularQueue.Rear(); // 返回 4提示：
- 所有的值都在 0 至 1000 的范围内；
- 操作数将在 1 至 1000 的范围内；
- 请不要使用内置的队列库。
class MyCircularQueue:
def __init__(self, k: int):
self.front = self.rear = 0
self.elements = [0] * (k + 1)
def enQueue(self, value: int) -> bool:
if self.isFull():
return False
self.elements[self.rear] = value
self.rear = (self.rear + 1) % len(self.elements)
return True
def deQueue(self) -> bool:
if self.isEmpty():
return False
self.front = (self.front + 1) % len(self.elements)
return True
def Front(self) -> int:
return -1 if self.isEmpty() else self.elements[self.front]
def Rear(self) -> int:
return -1 if self.isEmpty() else self.elements[(self.rear - 1) % len(self.elements)]
def isEmpty(self) -> bool:
return self.rear == self.front
def isFull(self) -> bool:
return (self.rear + 1) % len(self.elements) == self.front
力扣20 ----有效括号判断
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
- 左括号必须用相同类型的右括号闭合。
- 左括号必须以正确的顺序闭合。
- 每个右括号都有一个对应的相同类型的左括号。
示例 1：
输入：s = "()" 输出：true示例 2：
输入：s = "()[]{}" 输出：true示例 3：
输入：s = "(]" 输出：false提示：
- 1 <= s.length <= 104
- s 仅由括号 '()[]{}' 组成
分析
代码
class Solution:
def isValid(self, s: str) -> bool:
if len(s) % 2 == 1:
return False
pairs = {
")": "(",
"]": "[",
"}": "{",
}
stack = list()
for ch in s:
if ch in pairs:
if not stack or stack[-1] != pairs[ch]:
return False
stack.pop()
else:
stack.append(ch)
return not stack
