棧和隊列
棧
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())