def BuildGraph(
edges, directed, vertices
): # Edges list, directed or not directed, and number of vertices
graph = GraphAL(vertices,
directed) # Initialize empty graph with only vertices
for i in range(len(edges)): # Adds edges to graph
graph.add_edge(edges[i][0], edges[i][1], edges[i][2])
return graph
def topological_sort(graph):
start_time = time.clock()
all_in_degrees = []
sort_result = []
# q = Queue()
for i in range(GraphAL.get_num_vertices(graph)):
all_in_degrees.append(GraphAL.get_vertex_in_degree(graph, i))
# print(all_in_degrees)
q = Queue()
for i in range(len(all_in_degrees)):
if all_in_degrees[i] == 0:
q.put(i)
while not q.empty():
u = q.get()
sort_result.append(u)
for adj_vertex in range(len(graph.adj_list)):
all_in_degrees[adj_vertex] -= 1
if all_in_degrees[adj_vertex] == 0:
q.put(adj_vertex)
print(time.clock() - start_time, "seconds")
if len(sort_result) != graph.get_num_vertices():
return None
print(sort_result)
def kruskals_sort(graph):
# set up array
edges = graph.get_edges_as_list()
# sort nodes by weight
# since the graph is not that large, bubble sort is used in order to keep things simple
sort_edges_by_weight(edges)
# set up new graph
min_graph = GraphAL(int(graph.get_num_vertices()), graph.is_directed)
# insert nodes
for edge in edges:
#print("Adding edge " + str(edge.src) + " >>> " + str(edge.dest) + " weight " + str(edge.weight))
min_graph.add_edge(edge.src, edge.dest, edge.weight)
if min_graph.contains_cycle():
#print("Found cycle " + str(edge.src) + " >>> " + str(edge.dest))
min_graph.remove_edge(edge.src, edge.dest)
return min_graph
def main():
print("_________________________________")
print("Topological Sort")
print()
graph_topological = GraphAL(initial_num_vertices=6, is_directed=True)
graph_topological.add_edge(0, 1)
graph_topological.add_edge(0, 2)
graph_topological.add_edge(0, 4)
graph_topological.add_edge(1, 5)
graph_topological.add_edge(2, 3)
graph_topological.add_edge(3, 4)
print("The topological order of the vertices")
print(topological_sort(graph_topological))
graph_topological = GraphAL(initial_num_vertices=4, is_directed=True)
graph_topological.add_edge(0, 1)
graph_topological.add_edge(0, 2)
graph_topological.add_edge(1, 3)
graph_topological.add_edge(3, 2)
print("The topological order of the vertices")
print(topological_sort(graph_topological))
print("_________________________________")
print("Kruskals Algorithm")
graph_kruskal = GraphAL(initial_num_vertices=4, is_directed=False)
graph_kruskal.add_edge(0, 1, 7.0)
graph_kruskal.add_edge(1, 2, 3.0)
graph_kruskal.add_edge(0, 2, 4.0)
graph_kruskal.add_edge(1, 3, 7.0)
graph_kruskal.add_edge(2, 3, 1.0)
graph_kruskal.add_edge(1, 2, 2.0)
for value in kruskal(graph_kruskal):
print(value)
print("testing kruskal's algorithm with another graph")
graph_kruskal = GraphAL(initial_num_vertices=5, is_directed=False)
graph_kruskal.add_edge(0, 1, 7.0)
graph_kruskal.add_edge(2, 3, 6.0)
graph_kruskal.add_edge(1, 3, 5.0)
graph_kruskal.add_edge(1, 2, 4.0)
graph_kruskal.add_edge(0, 2, 3.0)
graph_kruskal.add_edge(1, 4, 2.0)
graph_kruskal.add_edge(3, 4, 1.0)
for value in kruskal(graph_kruskal):
print(value)
print()
def main():
print("STARTING MAIN")
# The following graph will be created
# 1 (8)
# (2)/ \ 3------5
# /(1)\ (3)/ /
# 2 \ / /(4)
# \-----0------4
# (10) (23)
# Set up graph size
user_graph = GraphAL(6, False)
# Add edges
user_graph.add_edge(0, 1, 1)
user_graph.add_edge(1, 2, 2)
user_graph.add_edge(2, 0, 10)
user_graph.add_edge(0, 3, 3)
user_graph.add_edge(0, 4, 23)
user_graph.add_edge(4, 5, 4)
user_graph.add_edge(3, 5, 8)
print("USING KRUSKAL'S ALGORITHM...")
# Show user graph
print("The graph adjacency list looks like this....")
user_graph.print_graph()
print("The min spanning tree looks like this...")
min_graph = kruskals_sort(user_graph)
min_graph.print_graph()
print("")
print("USING TOPOLOGICAL SORT...")
print("The min spanning tree looks like this...")
min_graph = topological_sort(user_graph)
print(min_graph)
def main():
graph = GraphAL(5, False)
graph = GraphAM(5, False)
Graph = GraphAL(5, True)
graph.add_edge(0, 1, 3)
graph.add_edge(0, 2, 5)
graph.add_edge(1, 3, 4)
graph.add_edge(1, 4, 2)
graph.add_edge(2, 3, 9)
graph.add_edge(2, 4, 7)
Graph.add_edge(0, 1)
Graph.add_edge(0, 2)
Graph.add_edge(1, 4)
Graph.add_edge(1, 3)
Graph.add_edge(2, 3)
Graph.add_edge(4, 2)
print("Kruskal's Algorithm:")
if Kruskals(graph, 0) != None:
for i in Kruskals(graph, 0):
print(i.item, "-", i.next, "; weight:", i.weight)
print("\nTopological Sort:")
print(topological_sort(Graph))
def BFS(graph, initial, final):
queue = deque()
queue.appendleft(initial)
visited = [0] * graph.size
while len(queue) != 0:
current = queue.pop()
if current == final:
return True
for son in graph.getSuccessors(current):
if visited[son] == 0:
visited[son] = 1
queue.appendleft(son)
return False
graph = GraphAL(5)
graph.addArc(0, 4, 7)
graph.addArc(3, 4, 3)
graph.addArc(4, 2, 5)
graph.addArc(0, 1, 2)
graph.addArc(1, 2, 1)
graph.addArc(2, 0, 8)
print(graph)
print("DFS:")
print("From 0 to 2:", DFS(graph, 0, 2))
print("From 2 to 3:", DFS(graph, 2, 3))
print("From 3 to 0:", DFS(graph, 3, 0))
print("From 4 to 3:", DFS(graph, 4, 3))
print("")
from GraphAL import GraphAL
from Algorithms import kruskal, topological_sort
graph = GraphAL(initial_num_vertices=4, is_directed=False)
graph.add_edge(0, 1, 6)
graph.add_edge(1, 3, 4)
graph.add_edge(0, 2, 1)
graph.add_edge(0, 3, 3)
graph.add_edge(1, 2, 5)
graph.add_edge(2, 3, 2)
min_spannig_tree = kruskal(graph)
for i in min_spannig_tree:
print(i)
print('\n')
graph = GraphAL(initial_num_vertices=10, is_directed=False)
graph.add_edge(0, 1, 4)
graph.add_edge(1, 2, 4)
graph.add_edge(2, 3, 8)
graph.add_edge(0, 4, 3)
graph.add_edge(4, 1, 2)
graph.add_edge(1, 5, 5)
graph.add_edge(5, 2, 6)
graph.add_edge(2, 6, 9)
graph.add_edge(6, 3, 13)
graph.add_edge(4, 5, 12)
def main():
# Graph 1
graph = GraphAL(initial_num_vertices=7, is_directed=True)
#graph = GraphAM(initial_num_vertices=11, is_directed=True)
graph.add_edge(0, 1)
graph.add_edge(0, 4)
graph.add_edge(1, 2)
graph.add_edge(2, 3)
graph.add_edge(3, 6)
graph.add_edge(4, 5)
graph.add_edge(4, 1)
graph.add_edge(5, 6)
graph.add_edge(5, 1)
graph.add_edge(5, 3)
# Graph 2
graph_2 = GraphAL(4, False)
graph_2.add_edge(0, 1, 6.0)
graph_2.add_edge(0, 2, 1.0)
graph_2.add_edge(0, 3, 3.0)
graph_2.add_edge(1, 2, 5.0)
graph_2.add_edge(1, 3, 4.0)
graph_2.add_edge(2, 3, 2.0)
start_time = time.time()
# Prints topological sort
order = graph_topological_sort(graph)
print("Topoloical Sort: ", order)
end_time = time.time() # Running Time
print("Topological Sort Running Time:", end_time - start_time)
print()
start_time = time.time()
# Prints kruskal's algorithm
order2 = graph_kruskals_alg(graph_2)
print("Kruskal's Algorithm (Minimum Spanning Tree):")
for i in range(len(order2)):
order2[i].print_edge()
end_time = time.time() # Running time
print("Kruskal's Algorithm Running Time:", end_time - start_time)
def main():
graph_kruskal_algorithm = GraphAL(vertices=4, directed=False)
graph_kruskal_algorithm.add_edge(0, 4, 5.0)
graph_kruskal_algorithm.add_edge(8, 7, 1.0)
graph_kruskal_algorithm.add_edge(9, 1, 3.0)
graph_kruskal_algorithm.add_edge(0, 2, 1.0)
graph_kruskal_algorithm.add_edge(0, 1, 7.0)
graph_kruskal_algorithm.add_edge(2, 1, 2.0)
print("minimum spanning tree")
for value in kruskal_algorithm(graph_kruskal_algorithm):
print(value)
# testing kruskal's algorithm with another graph
graph_kruskal_algorithm = GraphAL(vertices=5,
directed=False) # arbitrary values
graph_kruskal_algorithm.add_edge(0, 1, 7.0)
graph_kruskal_algorithm.add_edge(4, 5, 8.0)
graph_kruskal_algorithm.add_edge(2, 3, 4.0)
graph_kruskal_algorithm.add_edge(1, 2, 4.0)
graph_kruskal_algorithm.add_edge(0, 6, 3.0)
graph_kruskal_algorithm.add_edge(5, 4, 2.0)
graph_kruskal_algorithm.add_edge(2, 4, 1.0)
print("minimum spanning tree:")
for value in kruskal_algorithm(graph_kruskal_algorithm):
print(value)
# testing tropological's algorithm
graph_topological = GraphAL(vertices=6, directed=True)
graph_topological.add_edge(0, 1)
graph_topological.add_edge(0, 2)
graph_topological.add_edge(0, 3)
graph_topological.add_edge(2, 5)
graph_topological.add_edge(3, 4)
graph_topological.add_edge(5, 4)
print("The topological order of the first graph is:")
print(topological_sort(graph_topological))
# testing topological sorting algorithm with another graph
graph_topological = GraphAL(vertices=4, directed=True)
graph_topological.add_edge(0, 1)
graph_topological.add_edge(0, 2)
graph_topological.add_edge(1, 3)
graph_topological.add_edge(3, 2)
print("The topological order of the second graph is:")
print(topological_sort(graph_topological))
def main():
print("-----------------------------")
print(" Topological Sort ")
print("-----------------------------")
# This initializes an Adjacency List Graph
g = GraphAL(8, True)
g.add_edge(0, 1)
g.add_edge(1, 2)
g.add_edge(1, 3)
g.add_edge(3, 7)
g.add_edge(2, 4)
g.add_edge(2, 5)
g.add_edge(2, 6)
g.add_edge(4, 7)
g.add_edge(6, 4)
# This prints all vertices in the graph
print("Original vertices arrangement:")
for i in range(len(g.adj_list)):
print(i, sep=' ', end='', flush=True)
print(" ", sep=' ', end=' ', flush=True)
# This uses topological sort to sort the vertices
top_sort = topological_sort(g)
# This prints sorted vertices
print("\nTopological Sorted Vertices: ")
for j in top_sort:
print(j, sep=' ', end='', flush=True)
print(" ", sep=' ', end=' ', flush=True)
print()
print("\n-----------------------------")
print(" Kruskal's Algorithm ")
print("-----------------------------")
# This generates another graph which has the DSF methods inside its class
test_graph = Generic_Graph([0, 1], 5)
test_graph.add([0, 2], 3)
test_graph.add([0, 4], 6)
test_graph.add([1, 5], 2)
test_graph.add([1, 2], 2)
test_graph.add([2, 3], 1)
test_graph.add([3, 5], 4)
test_graph.add([3, 4], 1)
test_graph.add([4, 2], 2)
print("All edges and their corresponding weights: \n")
# The following method call prints all edges and their corresponding weights
test_graph.print_graph()
print("\nEdges selected for the Minimum Spanning Tree: \n")
# The following method call prints the edges selected for the Minimum Spanning Tree
test_graph.kruskal()
def main():
graph = GraphAL(initial_num_vertices=6, is_directed=True)
graph.add_edge(0, 1)
graph.add_edge(0, 4)
graph.add_edge(1, 2)
graph.add_edge(2, 3)
graph.add_edge(4, 5)
graph.add_edge(5, 2)
graph.add_edge(5, 3)
graph2 = GraphAL(initial_num_vertices=6, is_directed=True)
graph2.add_edge(0, 1, 1)
graph2.add_edge(0, 4, 21)
graph2.add_edge(1, 2, 3)
graph2.add_edge(2, 3, 13)
graph2.add_edge(4, 5, 4)
graph2.add_edge(5, 2, 15)
graph2.add_edge(5, 3, 6)
graph2.add_edge(1, 3, 7)
graph2.add_edge(1, 4, 9)
graph2.add_edge(1, 5, 10)
graph2.add_edge(0, 3, 14)
topological_sort(graph)
kruskalls(graph2)