def prim(graph: GraphAL) -> Dict[str, EdgeTuple]:
if graph.is_directed:
split_sign = ' -> '
else:
split_sign = ' <-> '
vnum = graph.vertex_num()
reps = graph.nodes_rep
mst = {}
edges_set = set()
start_node = list(reps.keys())[0]
candidates = PriorityQueueHeap([EdgeTuple(start_node, start_node, 0)])
while len(edges_set) < vnum and not candidates.is_empty():
edge_tuple = candidates.dequeue()
if mst.get(edge_tuple.end_node, None) is not None:
continue
mst[edge_tuple.end_node] = EdgeTuple(edge_tuple.start_node, edge_tuple.end_node, -1 * edge_tuple.weight)
edges_set.add(edge_tuple.end_node)
for edge_ in graph.out_edge(edge_tuple.end_node):
edge = edge_.split(split_sign)
end_node = edge_.split(split_sign)[1]
et = EdgeTuple(edge[0], edge[1], int(edge[2])*(-1))
if mst.get(end_node, None) is None:
candidates.enqueue(et)
return mst
def kruskal(graph: GraphAL) -> List[Tuple[str, str, int]]:
if graph.is_directed:
split_sign = ' -> '
else:
split_sign = ' <-> '
vnum = graph.vertex_num()
reps = graph.nodes_rep
mst, edges = [], set()
for vi in graph.vertices():
for edge in graph.out_edge(vi):
edge = edge.split(split_sign)
if edge[0] > edge[1] and not graph.is_directed:
edge[0], edge[1] = edge[1], edge[0]
et = EdgeTuple(edge[0], edge[1], int(edge[2]))
edges.add(et)
edges = list(edges)
edges.sort(key=lambda x: x.weight)
for individual_edge in edges:
if reps[individual_edge.start_edge] != reps[individual_edge.end_edge]:
mst.append((individual_edge.start_edge, individual_edge.end_edge, individual_edge.weight))
if len(mst) == vnum - 1:
break
rep, orep = reps[individual_edge.start_edge], reps[individual_edge.end_edge]
for i in graph.vertices():
if reps[i] == orep:
reps[i] = rep
return mst
def DFS_span_forest_non_recursive(graph: GraphAL) -> Dict[str, Any]:
nodes = graph.vertices()
span_forest = {}
def non_recursive_dfs(graph_in: GraphAL, node):
nonlocal span_forest
stack = LStack()
stack.push(node)
last_traverse = node
while not stack.is_empty():
top_node = stack.pop()
if span_forest.get(top_node, None) is not None and span_forest.get(
top_node, None) != '0':
continue
if span_forest.get(top_node, None) is None:
span_forest[top_node] = last_traverse
last_traverse = top_node
neighbors = sorted([
neighbor.split(" <-> ")[1]
for neighbor in graph_in.out_edge(top_node)
])[::-1]
for neighbor in neighbors:
if span_forest.get(neighbor, None) is None:
stack.push(neighbor)
for i in nodes:
if span_forest.get(str(i)) is None:
span_forest[str(i)] = '0'
non_recursive_dfs(graph, i)
return span_forest
def BSF_traversal_graph(graph: GraphAL):
queue = LQueue()
visited = set()
init_node = graph.vertices()[0]
visited.add(init_node)
yield init_node
queue.append(init_node)
while not queue.is_empty():
node = queue.pop()
neighbors = [
neighbor.split(" <-> ")[1] for neighbor in graph.out_edge(node)
]
for neighbor in sorted(neighbors):
if neighbor not in visited:
queue.append(neighbor)
visited.add(neighbor)
yield neighbor
def DFS_traversal_graph(graph: GraphAL):
visited = set()
stack = LStack()
init_node = graph.vertices()[0]
stack.push(init_node)
while not stack.is_empty():
node = stack.pop()
if node not in visited:
visited.add(node)
yield node
else:
continue
neighbors = sorted([
neighbor.split(" <-> ")[1] for neighbor in graph.out_edge(node)
])[::-1]
for neighbor in neighbors:
if neighbor not in visited:
stack.push(neighbor)
def bfs(graph_in: GraphAL, node):
nonlocal span_forest
queue = LQueue()
queue.append(node)
while not queue.is_empty():
top_node = queue.pop()
neighbors = sorted([
neighbor.split(" <-> ")[1]
for neighbor in graph_in.out_edge(top_node)
])
for neighbor in neighbors:
if span_forest.get(neighbor, None) is None:
queue.append(neighbor)
span_forest[neighbor] = top_node
def traversal_graph(graph: GraphAL):
seq = []
visited = set()
init_node = graph.vertices()[0]
def traversal_graph_util(node: Any, visited_in: Set[Any], seq):
visited_in.add(node)
seq.append(node)
neighbors = [
neighbor.split(" <-> ")[1] for neighbor in graph.out_edge(node)
]
for neighbor in sorted(neighbors):
if neighbor not in visited_in:
traversal_graph_util(neighbor, visited_in, seq)
traversal_graph_util(init_node, visited, seq)
print(seq)
def DSF_span_forest(graph: GraphAL) -> Dict[Any, Any]:
nodes = graph.vertices()
span_forest = {}
def dfs(graph_in, v):
nonlocal span_forest
for neighbor in sorted(graph_in.out_edge(v)):
node = neighbor.split(' <-> ')[1]
if span_forest.get(node, None) is None:
span_forest[node] = v
dfs(graph_in, node)
else:
continue
for i in nodes:
if span_forest.get(i) is None:
span_forest[i] = 0
dfs(graph, i)
return span_forest
def non_recursive_dfs(graph_in: GraphAL, node):
nonlocal span_forest
stack = LStack()
stack.push(node)
last_traverse = node
while not stack.is_empty():
top_node = stack.pop()
if span_forest.get(top_node, None) is not None and span_forest.get(
top_node, None) != '0':
continue
if span_forest.get(top_node, None) is None:
span_forest[top_node] = last_traverse
last_traverse = top_node
neighbors = sorted([
neighbor.split(" <-> ")[1]
for neighbor in graph_in.out_edge(top_node)
])[::-1]
for neighbor in neighbors:
if span_forest.get(neighbor, None) is None:
stack.push(neighbor)
def BFS_span_forest_non_recursive(graph: GraphAL) -> Dict[Any, Any]:
nodes = graph.vertices()
span_forest = {}
def bfs(graph_in: GraphAL, node):
nonlocal span_forest
queue = LQueue()
queue.append(node)
while not queue.is_empty():
top_node = queue.pop()
neighbors = sorted([
neighbor.split(" <-> ")[1]
for neighbor in graph_in.out_edge(top_node)
])
for neighbor in neighbors:
if span_forest.get(neighbor, None) is None:
queue.append(neighbor)
span_forest[neighbor] = top_node
span_forest['b'] = '0'
bfs(graph, 'b')
return span_forest
queue.append(init_node)
while not queue.is_empty():
node = queue.pop()
neighbors = [
neighbor.split(" <-> ")[1] for neighbor in graph.out_edge(node)
]
for neighbor in sorted(neighbors):
if neighbor not in visited:
queue.append(neighbor)
visited.add(neighbor)
yield neighbor
if __name__ == "__main__":
nodes = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
G = GraphAL()
for i in nodes:
G.add_vertex(i)
G.add_edge('a', 'b')
G.add_edge('a', 'd')
G.add_edge('a', 'c')
G.add_edge('b', 'd')
G.add_edge('b', 'g')
G.add_edge('b', 'e')
G.add_edge('c', 'd')
G.add_edge('c', 'f')
G.add_edge('d', 'g')
G.add_edge('e', 'g')
G.add_edge('f', 'g')
traversal_graph(G)
print("===========DFS-non-recursive==========")
continue
mst[edge_tuple.end_node] = EdgeTuple(edge_tuple.start_node, edge_tuple.end_node, -1 * edge_tuple.weight)
edges_set.add(edge_tuple.end_node)
for edge_ in graph.out_edge(edge_tuple.end_node):
edge = edge_.split(split_sign)
end_node = edge_.split(split_sign)[1]
et = EdgeTuple(edge[0], edge[1], int(edge[2])*(-1))
if mst.get(end_node, None) is None:
candidates.enqueue(et)
return mst
if __name__ == "__main__":
graph = GraphAL()
for i in "abcdefg":
graph.add_vertex(i)
graph.add_edge("a", "b", 5)
graph.add_edge("a", "c", 11)
graph.add_edge("a", "d", 5)
graph.add_edge("b", "d", 3)
graph.add_edge("b", "g", 7)
graph.add_edge("b", "e", 9)
graph.add_edge("c", "d", 7)
graph.add_edge("c", "f", 6)
graph.add_edge("d", "g", 20)
graph.add_edge("e", "g", 8)
graph.add_edge("f", "g", 8)
print(kruskal(graph))
print(prim(graph))