def hasCycleDFS(G):
for rootId in G.getNodes():
dfs_nodes = [] # qui è dove metteremo i Nodi Chiusi
# Inizializziamo la pila dove inseriamo i Nodi Aperti
s = Stack()
s.push(rootId.id)
explored = {rootId.id} # nodi visitati
while not s.isEmpty(): # finchè ci sono nodi da esplorare ...
node = s.pop() # prendiamo il nodo dalla pila
explored.add(node) # marchiamo il nodo
# aggiungiamo tutti i nodi adiacenti non esplorati nella pila
for i in range(len(G.getAdj(node)) - 1, -1, -1):
adj_node = G.getAdj(node)[i]
if adj_node not in explored:
explored.add(adj_node)
s.push(adj_node)
elif s.inPila(
adj_node
): # se il nodo adiacente è un nodo aperto allora abbiamo un ciclo!
return 1
dfs_nodes.append(node)
return 0
def __subtreeNodesNumber(self, node):
"""
:param node: radice del sottoalbero
:return: numero di nodi del sottoalbero radicato in node
"""
res = []
stack = PilaArrayList()
if node is not None:
stack.push(node)
while not stack.isEmpty():
current = stack.pop()
res.append(current.info)
if current.rightSon is not None:
stack.push(current.rightSon)
if current.leftSon is not None:
stack.push(current.leftSon)
return len(res)
def dfs(self, rootId):
"""
Execute a Depth-First Search (DFS) in the graph starting from the
specified node.
:param rootId: the root node ID (integer).
:return: the DFS list of nodes.
"""
# if the root does not exists, return None
if rootId not in self.nodes:
return None
# DFS nodes initialization
dfs_nodes = []
# queue initialization
s = Stack()
s.push(rootId)
explored = {rootId} # nodes already explored
while not s.isEmpty(): # while there are nodes to explore ...
node = s.pop() # get the node from the stack
explored.add(node) # mark the node as explored
# add all adjacent unexplored nodes to the stack
for i in range(len(self.getAdj(node)) - 1, -1, -1):
adj_node = self.getAdj(node)[i]
if adj_node not in explored:
explored.add(adj_node)
s.push(adj_node)
dfs_nodes.append(node)
return dfs_nodes
def hasCycleDFSIter(G):
"""
Esegue una visita DFS nel grafo G a partire dal primo nodo. Se un nodo non ancora visitato si trova già
nello stack, allora ai passi successivi si genererà un arco all'indietro, ovvero un arco da un nodo ad uno già
visitato. È importante notare che per ogni nodo non viene preso in considerazione l'arco diretto verso il padre,
poiché quest'ultimo è già marcato come visitato.
:param G: Graph.
:return: bool.
"""
# rootId = random.choice(list(G.nodes.keys())) # inizia la visita da un nodo random
rootId = list(G.nodes.keys())[0]
# DFS nodes initialization
dfsNodes = set()
# queue initialization
s = Stack()
s.push(rootId)
explored = {rootId} # nodes already explored
while not s.isEmpty(): # while there are nodes to explore ...
node = s.pop() # get the node from the stack
explored.add(node) # mark the node as explored
# add all adjacent unexplored nodes to the stack
for adjNode in G.getAdj(node):
if adjNode not in explored:
s.push(adjNode)
if node in dfsNodes:
return True
dfsNodes.add(node)
return False
def DFS(self):
"""
Permette di restituire una lista di elementi ottenuta da una visita
in profondità dell'albero.
:return: list nodi
"""
res = []
stack = Pila()
if self.root is not None:
stack.push(self.root)
while not stack.isEmpty():
current = stack.pop()
res.append(current.info)
if current.rightSon is not None:
stack.push(current.rightSon)
if current.leftSon is not None:
stack.push(current.leftSon)
return res
def print(self):
"""
Permette di stampare l'albero. Per farlo si usa una pila di appoggio
"""
stack = PilaArrayList()
if self.root is not None:
stack.push(
[self.root, 0]
) # pila di liste di due elementi [il nodo, il livello occupato dal nodo]
print("-- Tree --")
else:
print("Empty tree!")
return
while not stack.isEmpty():
current = stack.pop()
level = current[1]
print("|---" * level + str(current[0].info))
if current[0].rightSon is not None:
stack.push([current[0].rightSon, level + 1])
if current[0].leftSon is not None:
stack.push([current[0].leftSon, level + 1])
print("-- Tree End -- ")
def DFS(self):
"""
Permette di restituire una lista di elementi ottenuta da una visita
in profondità dell'albero.
:return: list nodi
"""
res = []
stack = Pila()
if self.root is not None:
stack.push(self.root)
while not stack.isEmpty():
current = stack.pop()
res.append(current.info)
for i in range(len(current.sons) - 1, -1, -1):
stack.push(current.sons[i])
return res
def foundNodeByElem(self, elem):
"""
Visita DFS per cercare un nodo che contenga l'indice richiesto.
:param elem: da cercare
:return: nodo
"""
stack = Pila()
if self.root is not None:
stack.push(self.root)
while not stack.isEmpty():
current = stack.pop()
if elem == current.info:
return current
for i in range(len(current.sons)):
stack.push(current.sons[i])
return None
def dfs(self, rootId, dimens):
"""
Execute a Depth-First Search (DFS) in the graph starting from the
specified node.
:param rootId: the root node ID (integer).
:return: the DFS list of nodes.
"""
# if the root does not exists, return None
if rootId not in self.nodes:
return None
# DFS nodes initialization
dfs_nodes = []
# queue initialization
s = Stack()
s.push(rootId)
explored = {rootId} # nodes already explored
while not s.isEmpty(): # while there are nodes to explore ...
node = s.pop() # get the node from the stack
explored.add(node) # mark the node as explored
# add all adjacent unexplored nodes to the stack
for adj_node in self.getAdj(node):
if adj_node not in explored:
s.push(adj_node)
dfs_nodes.append(node)
# viene aggiunto un semplice controllo,se nella dfs si passa per un nodo piu volte
# allora ce' un ciclo e si ritorna true
if dfs_nodes.count(node)>1:
print("Cycle detected!")
return True
# se il while termina il ciclo non cè e si ritorna false
print("NOT cycle.")
return False
def iterativeQuickSort(l, left, right, det=False):
theStack = Stack()
theStack.push(left)
theStack.push(right)
while not theStack.isEmpty():
right = theStack.pop()
left = theStack.pop()
if printSwitch.dumpOperations:
print("quickSortIter-step({},{})".format(left, right))
if right <= left:
continue
mid = partition(l, left, right, det)
theStack.push(left)
theStack.push(mid - 1)
theStack.push(mid + 1)
theStack.push(right)
def iterativeQuickSort(l, left, right, selectionAlgorithm, *otherParameters):
theStack = Stack()
theStack.push(left)
theStack.push(right)
while not theStack.isEmpty():
right = theStack.pop()
left = theStack.pop()
if printSwitch.dumpOperations:
print("quickSortIter-step({},{},{})".format(
left, right, selectionAlgorithm.__name__))
if right <= left:
continue
k = ceil(len(l[left:right + 1]) / 2)
median = selectionAlgorithm(l[left:right + 1], k, *otherParameters)
mid = partitionDet(l, left, right, median)
theStack.push(left)
theStack.push(mid - 1)
theStack.push(mid + 1)
theStack.push(right)
print("Required time: ", elapsed, "seconds.")
# to run this module directly (NOT imported in another one)
if __name__ == "__main__":
print("\nPushing elements...\n")
print("Pila - Lista Collegata")
sl = PilaListaCollegata()
pushTest(sl)
print("Pila - ArrayList_dummy")
sald = PilaArrayList_dummy()
pushTest(sald)
print("Pila - ArrayList")
sal = PilaArrayList()
pushTest(sal)
print("\nPopping elements...\n")
print("Pila - Lista Collegata")
popTest(sl)
print("Pila - ArrayList_dummy")
popTest(sald)
print("Pila - ArrayList")
popTest(sal)