def create_tree(self, n):
'''通过模拟对折N次纸，产生树'''
for i in range(n):
# 1.当前是第一次对折
if i == 0:
self.root = Node('down', None, None)
continue
# 2.当前不是第一次对折
# 定义辅助队列存储当前对折次数产生的节点,通过层序遍历的思想，找到叶子结点，叶子结点添加子节点
q = Queue()
q.enqueue(self.root)
while not q.is_empty():
# 从队列中弹出一个结点
temp = q.dequeue()
if temp.left is not None:
q.enqueue(temp.left)
if temp.right is not None:
q.enqueue(temp.right)
if temp.left is None and temp.right is None:
temp.left = Node('down', None, None)
temp.right = Node('up', None, None)
def edges(self):
'''获取最小生成树的所有边'''
# 创建队列对象
all_edges = Queue()
# 遍历edgeTo数组，拿到每一条边，如果不为null，则添加到队列中
for i in range(len(self.edge_to)):
if self.edge_to[i] is not None:
all_edges.enqueue(self.edge_to[i])
return all_edges
def __init__(self, g, s):
'''构造广度优先搜索对象，使用广度优先搜索找出G图中s顶点的所有相邻顶点'''
# 索引代表顶点，值表示当前顶点是否已经被搜索
self.marked = [None] * g.get_v()
# 记录有多少个顶点与s顶点相通
self.count = 0
# 用来存储待搜索邻接表的点
self.wait_search = Queue()
self.bfs(g, s)
def __init__(self, v):
# 初始化顶点数量
self._v = v
# 初始化边的数量
self._e = 0
# 初始化邻接表
self._adj = [Queue() for i in range(v)]
def path_to(self, v):
'''查询从起点s到顶点v的最短路径中所有的边'''
# 判断从顶点s到顶点v是否可达，如果不可达，直接返回null
if not self.has_path_to(v):
return None
# 创建队列对象
all_edges = Queue()
while True:
e = self.edge_to[v]
if e is None:
break
all_edges.enqueue(e)
v = e.from_v()
return all_edges
def __init__(self, v):
# 顶点数目
self.v = v
# 边的数量
self.e = 0
# 邻接表
self.adj = [Queue() for i in range(v)]
def get_all_edges(self):
'''获取加权有向图的所有边'''
# 创建一个队列对象，存储所有的边
all_edges = Queue()
# 遍历图中的每一个顶点，得到该顶点的邻接表，遍历得到每一条边，添加到队列中返回即可
for i in range(self._v):
t_q = self.adj(i)
# 遍历v顶点的邻接表，找到每一条和v关联的边
t_e = t_q.dequeue()
while t_e is not False:
all_edges.enqueue(t_e)
t_e = t_q.dequeue()
return all_edges
class BreadthFirstSearch(object):
'''广度优先搜索'''
def __init__(self, g, s):
'''构造广度优先搜索对象，使用广度优先搜索找出G图中s顶点的所有相邻顶点'''
# 索引代表顶点，值表示当前顶点是否已经被搜索
self.marked = [None] * g.get_v()
# 记录有多少个顶点与s顶点相通
self.count = 0
# 用来存储待搜索邻接表的点
self.wait_search = Queue()
self.bfs(g, s)
def bfs(self, g, v):
'''使用广度优先搜索找出G图中v顶点的所有相邻顶点'''
# 把v表示为已搜索
self.marked[v] = True
# 让顶点v进入队列，待搜索
self.wait_search.enqueue(v)
# 通过循环，如果队列不为空，则从队列中弹出一个待搜索的顶点进行搜索
while not self.wait_search.is_empty():
# 弹出一个待搜索的顶点
tmp = self.wait_search.dequeue()
# 遍历顶点v的邻接表，拿到每一个相邻的顶点，继续递归搜索
w = g.get_adj(tmp).dequeue()
while w is not False:
# 如果顶点w没有被搜索，则继续递归搜索
if not self.marked[w]:
self.bfs(g, w)
w = g.get_adj(v).dequeue()
# 相通顶点数量 + 1
self.count += 1
def get_marked(self, w):
'''判断w顶点与s顶点是否相通'''
return True if self.marked[w] is True else False
def get_count(self):
'''获取与顶点s相通的所有顶点的总数'''
return self.count
def get_all_edges(self):
'''获取加权无向图的所有边'''
# 创建一个队列对象，存储所有的边
all_edges = Queue()
# 遍历图中的每一个顶点，找到该顶点的邻接表，邻接表中存储了该顶点关联的每一条边
# 因为这是无向图，所以同一条边同时出现在了它关联的两个顶点的邻接表中，需要让一条边只记录一次；
for i in range(self._e):
t_q = self.adj(i)
# 遍历v顶点的邻接表，找到每一条和v关联的边
t_e = t_q.dequeue()
while t_e is not False:
# 因为是从0开始，所以这样便可以剔除掉重复的边
if t_e.other(i) < i:
all_edges.enqueue(t_e)
t_e = t_q.dequeue()
return all_edges
def layer_ergodic(self):
'''层序遍历：从根节点开始，依次往下，获取每一层节点的所有值'''
# 存储所有的节点
keys = Queue()
# 辅助队列
nodes = Queue()
nodes.enqueue(self.root)
while not nodes.is_empty():
# 从队列中弹出一个结点，把key放入到keys中
temp = nodes.dequeue()
keys.enqueue(temp)
# 判断当前结点还有没有左子结点，如果有，则放入到nodes中
if temp.left is not None:
nodes.enqueue(temp.left)
# 判断当前结点还有没有右子结点，如果有，则放入到nodes中
if temp.right is not None:
nodes.enqueue(temp.right)
return keys