栈和队列
栈
1. 定义
栈是限制在一端进行插入操作和删除操作的线性表(俗称堆栈),允许进行操作的一端称为“栈顶”,另一固定端称为“栈 底”,当栈中没有元素时称为“空栈”。
2. 特点:
栈只能在一端进行数据操作
栈模型具有先进后出或者叫做后进先出的规律
3. 栈的代码实现
栈的操作有入栈(压栈),出栈(弹栈),判断栈的空满等操作。
顺序存储代码实现:
"""
(重点)栈的顺序存储结构
"""
class StackError(Exception):
pass
class SStack:
def __init__(self):
self._elements = []
# 返回栈顶元素
def top(self):
if not self._elements:
raise StackError("stack is empty")
return self._elements[-1]
# 是否为空
def is_empty(self):
return self._elements == []
# 入栈
def push(self, elem):
self._elements.append(elem)
# 出栈
def pop(self):
if not self._elements:
raise StackError("stack is empty")
return self._elements.pop()
# 检查指定内容中括号是否匹配
def check_bracket(self, value):
role = {'(': ')', '[': ']', '{': '}'}
if len(value) > 0:
for c in value:
if c in "([{":
self.push(c)
elif c in ")]}":
try:
temp = self.pop()
if c == role[temp]:
continue
else:
return False
except StackError:
return False
if len(self._elements):
return False
return True
else:
raise StackError("txt is empty")
if __name__ == '__main__':
stack = SStack()
txt = "{(这)是一个(有趣)的[故事]}"
print(stack.check_bracket(txt))
链式存储代码实现:
"""
(重点)栈的链式存储结构
"""
class StackError(Exception):
pass
class Node:
def __init__(self, name, next=None):
self.name = name
self.next = next
def __str__(self):
return str(self.name)
class LStack:
def __init__(self):
self._top = None
def is_empty(self):
return self._top is None
def push(self, value):
self._top = Node(value, self._top)
def pop(self):
p = self._top
self._top = p.next
return p
def top(self):
if not self._top:
raise StackError("stack is empty")
return self._top
if __name__ == '__main__':
stack = LStack()
stack.push(10)
stack.push(20)
print(stack.top())
队列
1. 定义
队列是限制在两端进行插入操作和删除操作的线性表,允许进行存入操作的一端称为“队尾”,允许进行删除操作的一端称为“队头”。
2. 特点:
队列只能在队头和队尾进行数据操作
队列模型具有先进先出或者叫做后进后出的规律
3. 队列的代码实现
队列的操作有入队,出队,判断队列的空满等操作。
顺序存储代码实现:
"""
顺序队列
"""
class QueueError(Exception):
pass
class SSqueue:
def __init__(self):
self._elements = []
# 清空队列
def clear(self):
self._elements = []
# 是否为空
def is_empty(self):
return self._elements == []
# 入队
def enqueue(self, value):
self._elements.append(value)
# 出队
def dequeue(self):
if not self._elements:
raise QueueError("queue is empty")
return self._elements.pop(0)
if __name__ == '__main__':
queue = SSqueue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
queue.enqueue(4)
while not queue.is_empty():
print(queue.dequeue())
链式存储代码实现:
"""
队列链式存储
"""
class Node:
def __init__(self, value, n=None):
self.name = value
self.next = n
class LQueue:
def __init__(self):
self.head = self.end = Node(None)
# 入队
def enqueue(self, value):
self.end.next = Node(value)
self.end = self.end.next
# 出队
def dequeue(self):
self.head = self.head.next
return self.head.name
# 清队
def clear(self):
self.end = self.head
# 是否为空
def is_empty(self):
return self.head == self.end
def length(self):
length = 0
p = self.head
while p.next:
length += 1
p = p.next
return length
if __name__ == '__main__':
queue = LQueue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
print(queue.is_empty())
print(queue.length())
while queue.head != queue.end:
print(queue.dequeue())