BFS Python

La ricerca nel campo della programmazione è principalmente divisa in due tipi, prima ricerca (DFS) e prima ricerca (BFS). Questi sono gli algoritmi della ricerca utilizzati per cercare o attraversare nel grafico.

La prima ricerca è il fenomeno di attraversare ogni nodo del grafico o di un albero, quindi ogni nodo è attraversato da due parti. Uno è la parte "visitata" e l'altra è la parte "non visitata". Ciò significa che questa ricerca mira a raggiungere ogni nodo del grafico.

BFS Pseudocodice e algoritmo

• Il primo passo è mettere qualsiasi primo nodo di origine nella coda dal retro.
• Crea l'elenco o l'array visitato e quindi metti i nodi.
• Usa un giro di while per verificare che la coda non sia vuota, quindi continua a rimuovere gli elementi nell'elenco visitato.
• Tutti gli articoli rimossi sono contrassegnati come visitati e ora rimuovono anche i vicini non visitati dalla coda.

Applicazioni di BFS

• È usato per la navigazione GPS.
• È utilizzato per trovare il percorso.
• Viene utilizzato per creare l'indice per indice di ricerca.
• Implementazione di BFS.

Esempio 1

Prima introduciamo il grafico; Vogliamo avere i valori che devono essere attraversati. Ogni nodo contiene ulteriormente i valori. Ad esempio, qui, il primo numero 5 si collegherà con i due nodi 3 e 7. Allo stesso modo, tutti gli altri numeri sono collegati con altri nodi per formare un grafico. Dopo aver definito il grafico, conteneremo due tipi di dati interi dell'array per archiviare i valori numerici del grafico che devono essere visitati. Mentre l'altro include quei nodi accanto a quelli che vengono visitati.

Visitato = []
Queue = []

Entrambi gli array sono vuoti al momento dell'avvio della prima ricerca. Ma gradualmente, questi array contengono i valori dei nodi come abbiamo descritto nel grafico.

Dopo aver introdotto due array, definiremo una funzione per accedere e cercare tutti i nodi dal punto di vista della linea. Questa funzione prende i valori dell'array visitato, il grafico e il terzo è il nodo. All'interno della funzione, aggiungeremo valori in entrambi gli array, come descritto nell'algoritmo; Innanzitutto, i valori vengono inseriti all'interno della "coda"; Quando viene visitato, quel particolare nodo viene quindi trasferito alla coda visitata. Quindi, per ora, questa funzione aggiungerà i valori negli array utilizzando una funzione di append per ciascun array. Questa funzione contiene i nodi come parametro in essa.

Visitato.append (nodo)
Coda.append (nodo)

Dopodiché, ora accederemo e visiteremo i nodi attraverso un approccio. Questo modo di accedere ai nodi è simile all'accesso agli array perché applichiamo sempre un ciclo per visitare ogni indice iterativamente. Nel caso di BFS, useremo un ciclo while, e all'interno di questo mentre loop, viene aggiunto un ciclo per soddisfare la condizione utilizzata dal loop while.

Questo While Loop mira direttamente alla coda perché i nodi verranno aggiunti prima alla coda e poi all'array visitato. Quindi i valori verranno estratti attraverso la funzione pop () e verranno archiviati nelle rispettive variabili.

M = coda. Pop (0)

Questo valore verrà visualizzato sulla chiamata della funzione di stampa. Ora quando vengono estratti i valori della coda, questo valore verrà utilizzato per individuare i suoi vicini che devono essere inseriti nella coda. Quindi useremo per loop qui per allocare ogni vicino fino alla fine del grafico. La condizione applicata qui è che se il valore non è nell'array visitato, significa che non è stato accessibile in precedenza, l'array visitato verrà aggiunto da questi nuovi valori (vicino) tramite la funzione di append. Allo stesso modo, la coda otterrà anche il valore dei nuovi vicini.

Visitato. Append (vicino)

La chiamata di funzione viene effettuata insieme all'array visitato, all'intero grafico e al nodo come parametro.

BFS (visitato, grafico, '5')

Dopo aver utilizzato questo codice, è possibile visualizzare l'output pertinente tramite la console risultante utilizzando il pulsante di esecuzione nella parte superiore della barra degli strumenti.

Puoi vedere che l'intero percorso sarà accessibile tramite i nodi. Una cosa può essere osservata qui: tutti questi nodi iniziali vengono visualizzati solo perché ogni volta prima della funzione di stampa, questi nodi vengono espulsi dalla coda.

Esempio 2

Questo esempio funziona sulla stessa tecnica: la ricerca all'interno del grafico o di un albero. Ma qui, abbiamo usato l'approccio di OOP (programmazione orientata agli oggetti) in Python usando il sistema di classe. Quindi, in primo luogo, importeremo alcune funzionalità dalla libreria delle collezioni. Queste caratteristiche includono il "defaultDict" che contiene il dizionario in linguaggio Python.

Muovendosi verso la classe, in primo luogo, definiamo il nome di classe e all'interno della classe, ecco il costruttore. Come costruttori sono quelle funzionalità che vengono eseguite automaticamente mentre creiamo l'oggetto della classe. L'oggetto della classe è necessario per accedere alle funzionalità della classe. Creeremo anche l'oggetto per la classe grafica più avanti nell'articolo. Innanzitutto, il costruttore è definito qui per inizializzare l'elenco preso come grafico.

DefaultDict (elenco)

"IS" utilizzato per archiviare il grafico nel dizionario predefinito.

Successivamente, una funzione viene utilizzata qui, "aggiunta" per aggiungere il nuovo nodo o bordo al grafico. I nodi sono anche noti come bordi e sono rappresentati da 'u,.Al contrario, la distanza tra i bordi è rappresentata dal vertice ed è menzionata da "V.'Quindi all'interno della funzione, il grafico sarà intrattenuto con nuovi nodi attraverso la funzione di append.

Se stesso.Grafico [U]. append (v)

Qui abbiamo anche usato una funzione per visualizzare il BFS di un grafico. Inizialmente, tutti i nodi sono dichiarati in quanto non vengono visitati. Nella prima fase della ricerca, dichiareremo lo stato come falso.

Visitato = [false] * (max (self.grafico) + 1)

Allo stesso modo, la coda viene inizializzata come zero al momento della creazione.

Queue = []

Parliamo ora del nodo di origine, che è il primo; Lo inseriremo nell'array visitato e lo estrarremo dalla coda come abbiamo fatto nel primo esempio.

Coda.append (i)
Visitato [s] = vero

Ora un ciclo while viene utilizzato per dequelare tutti i nodi dalla coda e quindi stamperà il valore.

S = coda.pop (0)

Successivamente, tutti i nodi adiacenti del vicino verranno estratti dalla coda; Se viene già visitato un nodo, questo verrà inserito nella coda visitata. Se la dichiarazione viene utilizzata per verificare se il nodo non viene già visitato, aggiungilo dalla coda e inseriscilo nell'array visitato.

G = grafico () è in qualche modo un modo per la creazione di oggetti del costruttore e questo oggetto viene ulteriormente utilizzato per chiamare la funzione aggiunta insieme ai valori vicini.

Conclusione

L'articolo "BFS-Python" contiene una breve descrizione della prima ricerca nel grafico per attraversare ogni nodo. Questo processo di ricerca viene eseguito avendo due elenchi che contengono nodi visitati e non visitati. Abbiamo elaborato il concetto aggiungendo due esempi elementari nella guida.