Cari lettori, in questo articolo vi guiderà attraverso il concetto di Depth First Search (DFS). Questo è un concetto grafico che è un problema comune in molti esami di codifica competitivi. Quindi, diamo un’occhiata alla creazione di un attraversamento DFS usando Python.
Indice
Qual è la profondità prima ricerca?
La ricerca depth-first è un algoritmo che utilizza la struttura dei dati dello Stack per attraversare grafici e alberi. Il concetto di ricerca di profondità-prima deriva dalla parola “profondità”. L’albero attraversa fino alla profondità di un ramo e poi di nuovo attraversa il resto dei nodi.
Considera uno “Stack” vuoto che contiene i nodi visitati per ogni iterazione. Il nostro compito qui è il seguente:
- Inizia dal nodo radice e spingilo sullo stack.
- Controllare eventuali nodi adiacenti dell’albero e selezionare un nodo.
- Attraversare l’intero ramo del nodo selezionato e spingere tutti i nodi nello stack.
- Una volta raggiunta la fine di un ramo (non più nodi adiacenti) cioè l’ennesimo nodo foglia, tornare indietro di un singolo passaggio e cercare i nodi adiacenti del n-1 ° nodo.
- Se ci sono nodi adiacenti per il n-1 ° nodo, attraversare quei rami e spingere i nodi sullo stack.
Concetto di profondità Prima ricerca illustrata
Diamo un’occhiata al nostro grafico di esempio qui sotto:
A è il nodo radice. Quindi, dal momento che A è visitato, spingiamo questo sulla pila.
Stack : A
Andiamo al ramo A-B. B non è visitato, quindi andiamo a B e spingiamo B sullo stack.
Stack : A B
Ora, siamo arrivati alla fine del nostro ramo A-B e ci spostiamo al n-1 ° nodo che è A. Ora guarderemo il nodo adiacente di A che è S. Visita S e spingilo sullo stack. Ora devi attraversare il ramo S-C-D, fino alla profondità cioè fino a D e segnare S, C, D come visitato.
Stack: A B S C D
Poiché D non ha altri nodi adiacenti, torna a C e attraversa il suo ramo adiacente EHG fino alla profondità e spingili sullo stack.
Stack : A B S C D E H G
Al raggiungimento di D, c’è solo un nodo adiacente, cioè F, che non viene visitato. Spingere F sulla pila pure.
Stack : A B S C D E H G F
Questo stack stesso è l’attraversamento del DFS.
Codifica Profondità Primo algoritmo di ricerca in Python
Come si deve essere consapevoli, ci sono molti metodi per rappresentare un grafico che è la lista adiacenza e matrice adiacenza.
Quindi nell’esempio seguente, ho definito un elenco di adiacenza per ciascuno dei nodi nel nostro grafico.
graph1 = { 'A' : , 'B' : , 'C' : , 'D' : , 'E' : , 'F' : , 'G' : , 'H' : , 'S' : }
Nota: Questa lista di adiacenza può essere immessa dall’utente e non deve essere codificata.
Ora, definiremo la nostra funzione DFS che prende in 3 parametri come input: il grafico (elenco adiacenze), un nodo e un elenco di nodi visitati.
Se il nodo corrente non è visitato, cioè non è presente nell’elenco visitato, contrassegnarlo come visitato e aggiungerlo all’elenco visitato.
Passare al nodo successivo e quindi passare ricorsivamente questo nodo nella funzione DFS. In questo modo ogni nodo si sposta fino alla profondità e lo stampa come output DFS.
def dfs(graph, node, visited): if node not in visited: visited.append(node) for k in graph: dfs(graph,k, visited) return visitedvisited = dfs(graph1,'A', )print(visited)
Codice Completo e di Uscita
graph1 = { 'A' : , 'B' : , 'C' : , 'D' : , 'E' : , 'F' : , 'G' : , 'H' : , 'S' : }def dfs(graph, node, visited): if node not in visited: visited.append(node) for k in graph: dfs(graph,k, visited) return visitedvisited = dfs(graph1,'A', )print(visited)
L’output del codice di cui sopra è il seguente:
Conclusione
spero che tu abbia seguito questo tutorial su DFS algoritmo e sono stati in grado di capire il codice e l’esempio. Provalo usando carta e penna accanto a te per capire meglio gli attraversamenti.