《数据结构与算法 python语言描述》学习笔记（五）———— 栈和队列
第一部分：学习内容概要
- 概述
- 栈：概念和实现
- 栈的应用
- 队列
- 迷宫求解和状态空间搜索
第二部分：学习笔记
-
概述
1. 栈是保证元素后进先出（Last In First On，LIFO）
2. 队列是保证元素先进先出（First In First On， FIFO）
3. 应用环境：
计算过程分为一些顺序进行的步骤（任何复杂一点的计算都是这样）
计算中执行的某些步骤会不断产生一些后面可能需要的中间数据
产生的数据中有些不能立即使用，但有需要在将来使用
需要保存的数据的项数不能事先确定 -
栈：概念和实现
1. 栈（Stack）是一种容器，可存入数据元素、访问元素、删除元素等。
2. 栈的抽象数据类型
ADT Stack:
Stack(self) #创建空栈
is_empty(self) #判断栈是否为空，空时返回Ture否则返回False
push(self,elem) #将元素elem加入栈，也常称为压入或推入
pop(self) #删除栈内最后压入的元素并将其返回，常称为弹出
top(self) #取得栈里最后压入的元素，不删除
3.栈的顺序表实现，后端插入和删除是O(1)操作，对于链接表，前端插入和删除都是O(1)操作。
'''栈的顺序表实现'''
class StackUnderflow(ValueError):
pass
class SStack():
def __init__(self):
self._elem = []
def is_empty(self):
return self._elem == []
def top(self):
if self._elem == []:
raise StackUnderflow("in SStack.top()")
return self._elem[-1]
def push(self, elem):
self._elems.append(elem)
def pop(self):
if self._elems == []:
raise StackUnderflow("in SStack.top()")
return self._elems.pop()
'''栈的链接表实现'''
class StackUnderflow(ValueError):
pass
class LStack():
def __init__(self):
self._top = None
def is_empty(self):
return self_top is None
def top(self):
if self._top is None:
raise StackUnderflow("in LStack.top()")
return self._top.elem
def push(self, elem):
self._top = LNode(elem, self._top)
def pop(self):
if self._top is None]:
raise StackUnderflow("in LStack.top()")
p = self._top
self._top = p.next
return p.elem
- 栈的应用
1. 括号匹配问题：
① 顺序扫描被检查正文里的一个个字符
② 检查中跳过无关字符
③ 遇到开括号时将其压入栈
④ 遇到闭括号是弹出当时栈顶元素与之匹配
⑤ 如果匹配成功则继续，发现不匹配时检查以失败结束
2. 表达式的表示、计算和变换
中缀形式：（3 - 5） * （6 + 17 * 4）/ 3
前缀形式：/ * - 3 5 + 6 * 17 4 3
后缀形式：3 5 - 6 17 4 * + * 3 /
3. 简单背包问题
''' 括号匹配文图'''
parens = "()[]{}"
open_parens = "([{"
opposite = {
")": "(", "[": "]", "}": "{"
}
def check_parens(text):
parens = "()[]{}"
open_parens = "([{"
opposite = {
")": "(", "[": "]", "}": "{"
}
def parentheses(text):
i, text_len = 0, len(text)
while True:
while i < text_len and text[i] not in parens:
i += 1
if i >= text_len:
return
yield text[i], i
i += 1
st = SStack()
for pr, i in parentheses(text):
if pr in open_parens:
st.push(pr)
elif st.pop() != opposite[pr]:
print("Unmatching is found at", i, "for", pr)
return False
print("All parentheses are correctly matched.")
return True
'''后缀表达式'''
def suffix_exp_evaluator(line):
return suffix_exp_evaluator(line.split())
class ESStack(SStack):
def depth(self):
return len(self._elems)
def suf_exp_evaluator(exp):
operators = "+-*/"
st = ESStack()
for x in exp:
if x not in operators:
st.push(float(x))
continue
if st.depth() < 2:
raise SyntaxError("Short of operand(s).")
a = st.pop()
b = st.pop()
if x == "+":
c = b + a
elif x == "-":
c = b - a
elif x == "*":
c = b * a
elif x == "/":
c = b / a
else:
break
st.push(c)
if st.depth():
return st.pop()
raise SyntaxError("Extra operand(s).")
- 队列
队列，或称为队，也是一种容器，可存入元素、访问元素、删除元素。
1.队列的抽象数据类型
ADT Queue:
Queue(self) #创建空队列
is_empty(self) #判断队列是否为空
enqueue(self, elem) #将元素elem加入队列，常称为入队
dequeue(self) #删除队列里最早进入的元素并将其返回，常称为出队
peek(self) #查看队列里最早进入的元素，不删除
队列类的实现
class SQueue():
def __init__(self, init_len=8):
self._len = init_len
self._elems = [0] * init_len
self._head = 0
self._num = 0
def is_empty(self):
return self._num
def peek(self):
if self._num = 0:
raise QueueUnderflow
return self._elems[self._head]
def dequeue(self):
if self._num == 0:
raise QueueUnderflow
e = self._elems[self._head]
self._head = (self._head+1) % self._len
self._num -= 1
return e
def enqueue(self, e):
if self._num == self._len:
self.__extend()
self._elems[(self._head+self._num) % self._len] = e
self._num += 1
def __extend(self):
old_len = self._len
self._len *= 2
new_elems = [0]*self._len
for i in range(old_len):
new_elems[i] = self._elems[(self._head+i) % old_len]
self._elems, self._head = new_elems, 0
- 迷宫求解和状态空间搜索
'pos为二元序对（i, j）普通方法'
dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]
def mark(maze, pos): #给迷宫maze的位置pos标2表示“到过了”
maze[pos[0]][pos[1]] = 2
def passable(maze, pos): #检查迷宫maze的位置pos时候可行
return maze[pos[0]][pos[1]] == 0
def find_path(maze, pos, end):
mark(maze, pos)
if pos == end: #已到达出口
print(pos, end=" ") #输出这个位置
return True #成功结束
for i in range(4): #否则按四个方向顺序探查
nextp = pos[0] + dirs[i][0], pos[1] + dirs[i][1]
#考虑下一个可能方向
if passable(maze, nextp):
if find_path(maze, nextp, end):
print(pos, end=" ") # 输出这个位置
return True
return False
'''堆栈实现'''
class StackUnderflow(ValueError):
pass
dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]
def mark(maze, pos): #给迷宫maze的位置pos标2表示“到过了”
maze[pos[0]][pos[1]] = 2
def passable(maze, pos): #检查迷宫maze的位置pos时候可行
return maze[pos[0]][pos[1]] == 0
class SStack():
def __init__(self):
self._elem = []
def is_empty(self):
return self._elem == []
def top(self):
if self._elem == []:
raise StackUnderflow("in SStack.top()")
return self._elem[-1]
def push(self, elem):
self._elems.append(elem)
def pop(self):
if self._elems == []:
raise StackUnderflow("in SStack.top()")
return self._elems.pop()
def maze_solver(maze, start, end):
if start == end:
print(start)
return
st = SStack()
mark(maze, start)
st.push((start, 0))
while not st.is_empty():
pos, nxt = st.pop()
for i in range(nxt, 4):
nextp = (pos[0] + dirs[i][0],
pos[1] + dirs[i][1])
if nextp == end:
print("maze end")
return
if passable(maze, nextp):
st.push((pos, i+1))
mark(maze, nextp)
st.push((nextp, 0))
break
print("No path found.")