def __init__(self, graph=defaultdict(list)):
self.graph = graph
self.visited = defaultdict(list)
self.__queue = Queue()
self.shortest_path_distance = dict() #Application 1 BFS
self.topological_ordering = {} #Application DFS 1
self._current_label = None
self.__stack = Stack() #Application DFS 2
def levelOrderTraversal(rootNode):
if not rootNode:
return
else:
customQueue = Queue()
customQueue.enqueue(rootNode)
while not (customQueue.isempty()):
root = customQueue.dequeue()
print(root.value.data)
if root.value.leftChild is not None:
customQueue.enqueue(root.value.leftChild)
if root.value.rightChild is not None:
customQueue.enqueue(root.value.rightChild)
def testQueueLinkedList():
Q = Queue()
while True:
print("Choose operation: ")
print(" 1 - Enqueue\n", "2 - Dequeue\n", "3 - Size\n", "4 - Exit\n")
choice = input()
if choice == '1':
Q = enqueue(Q)
elif choice == '2':
Q = dequeue(Q)
elif choice == '3':
getSize(Q)
elif choice == '4':
break
else:
print("BAD Choice! Choose from 1 to 4 numbers")
class Graph(object):
def __init__(self, graph=defaultdict(list)):
self.graph = graph
self.visited = defaultdict(list)
self.__queue = Queue()
self.shortest_path_distance = dict() #Application 1 BFS
self.topological_ordering = {} #Application DFS 1
self._current_label = None
self.__stack = Stack() #Application DFS 2
def __checkVertex(self, vertex):
if vertex not in self.graph:
self.graph[vertex] = []
def init_visited(self):
for v in self.graph:
self.visited[v] = False
def add_edge(self, vertex1, vertex2):
self.__checkVertex(vertex1)
self.__checkVertex(vertex2)
self.graph[vertex1].append(vertex2)
def BFS(self,source_vertex,shortest_path = False,\
connected_component = False): #both applications
if not connected_component:
self.init_visited()
self.visited[source_vertex] = True
self.__queue.enqueue(source_vertex)
if shortest_path:
self.shortest_path_distance[source_vertex] = 0
while not self.__queue.isEmpty():
v = self.__queue.dequeue()
if not shortest_path:
print(v, end=' ')
for vertex in self.graph[v]:
if not self.visited[vertex]:
if shortest_path:
self.shortest_path_distance[vertex] = \
self.shortest_path_distance[v] + 1
self.visited[vertex] = True
self.__queue.enqueue(vertex)
print()
def shortest_path(self, source_vertex):
self.BFS(source_vertex, shortest_path=True)
for v in self.shortest_path_distance:
print("Shortest path distance from " \
,source_vertex," to vertex ",v,
" = ",self.shortest_path_distance[v])
def connected_components(self):
self.init_visited()
count = 1
for vertex in self.graph:
if not self.visited[vertex]:
print("Connected Component ", \
count,": ",end = '')
self.BFS(vertex, connected_component=True)
count += 1
def __getReverse(self):
g = defaultdict(list) #will never throw KeyError
for vertex in self.graph:
for v in self.graph[vertex]:
g[v].append(vertex)
return Graph(g)
def DFS(self,source_vertex,topological_ordering=False, \
strongly_connected=False):
self.visited[source_vertex] = True
if (not topological_ordering) and (not strongly_connected):
print(source_vertex, end=' ')
for v in self.graph[source_vertex]:
if not self.visited[v]:
self.DFS(v, topological_ordering, strongly_connected)
if topological_ordering: #Application 1
self.topological_ordering[source_vertex] = \
self._current_label
self._current_label -= 1
if strongly_connected: #Application 2
self.__stack.push(source_vertex)
def get_topological_ordering(self):
self.init_visited()
self._current_label = len(self.graph)
for vertex in self.graph:
if not self.visited[vertex]:
self.DFS(vertex, topological_ordering=True)
return self.topological_ordering
def strongly_connected_components(self):
'''
geeksforgeeks implementation alias
self.init_visited()
for v in self.graph:
if not self.visited[v]:
self.DFS(v,strongly_connected = True)
reverse = self.__getReverse()
reverse.init_visited()
self.__stack.displayStack()
while not self.__stack.isEmpty():
vertex = self.__stack.pop()
if not reverse.visited[vertex]:
reverse.DFS(vertex)
print()
'''
self.init_visited() #course implementation
reverse = self.__getReverse()
reverse.init_visited()
for v in self.__getReverse(
).graph: #using self.__getReverse() cuz of error
# equivalent to reverse.graph
if not reverse.visited[v]:
reverse.DFS(v, strongly_connected=True)
self.__stack = reverse.__stack
#self.__stack.displayStack()
while not self.__stack.isEmpty():
vertex = self.__stack.pop()
if not self.visited[vertex]:
self.DFS(vertex)
print()
def displayGraph(self):
print()
print(self.graph)