Attraversa per la ricerca di ampiezza in JavaScript

In questo moderno mondo tecnologico, siamo tenuti a utilizzare le tecniche per attraversare gli alberi a livello di livello.

Larghezza prima ricerca è un attraversamento algoritmo Questo è usato per Ricerca o attraversare i dati dell'albero o del grafico Struttura strato per strato. Prima di passare al nodo per bambini del livello di profondità successivo, visita ogni nodo che esiste alla profondità corrente.

Questo articolo spiegherà come eseguire il Algoritmo di ricerca in larghezza Usando un esempio appropriato. Quindi iniziamo

Come funziona l'algoritmo di ricerca in larghezza in JavaScript

Il funzionamento dell'algoritmo di ricerca in larghezza comprende i seguenti passaggi:

• Scegliere un nodo e crea un file coda con tutto il suo vicino nodi.
• Rimuovere quelli nodi Dalla coda che vengono visitate e contrassegnarli.
• Aggiungere tutto il suo nodi vicini in coda.
• Ripetere fino a quando la coda diventa vuoto Oppure raggiungi il tuo obiettivo.

Se un nodo viene rivisitato prima che non fosse contrassegnato come visitato, il programma verrà fermato. Quindi, contrassegnare i nodi visitati e quindi non verrà nuovamente cercato.

Implementazione dell'algoritmo di attraversamento della ricerca in ampiezza

Larghezza prima ricerca Attraversa gli alberi da sinistra a destra, quindi si sposta dall'alto verso il basso (nodo genitore al nodo figlio). Garantire che tutti i nodi presenti sulla profondità attuale siano visitati.

Ora, diamo un'occhiata a un piccolo esempio per capire il Bfs La traversa funziona. Qui, il grafico non diretto ha 5 nodi "0", "1", "2", "3" e "4":

Ora useremo questo algoritmo di attraversamento sul grafico specificato.

Passaggio 1: inizializzazione della coda

Prima di tutto, dobbiamo Inizializza la coda "Q":

Passaggio 2: scegli il nodo iniziale

Successivamente, sceglieremo il nodo iniziale. A tale scopo, selezioneremo "0" come nodo iniziale e contrassegnarlo come visitato:

Passaggio 3: nodi adiacenti non visitati del nodo iniziale

Il nodo iniziale è visitato e contrassegnato; Ora, controlleremo nodi adiacenti. Nell'illustrazione seguente, Nodo iniziale "0" ha Tre nodi adiacenti non visitati "1", "2" e "3"; Tuttavia, sceglieremo il nodo "1" a causa del sequenza di conteggio. Poi, segno come visitato E aggiungere esso al coda:

Ora il non visitato nodo di "0" è "2", che è anche contrassegnato come visitato e aggiunto alla coda:

Allora lo faremo visita l'ultimo nodo adiacente non visitato, che è "3", lo ha segnato come Visitato e accusarlo:

Passaggio 4: dequeue il nodo iniziale

Ora il nostro nodo iniziale selezionato "0" non ha nodi adiacenti non visitati, quindi rimuoveremo la coda e cercheremo il nodo "1":

Passaggio 5: controllare il non visitato adiacente al nodo "1"

A questo punto, nodo "1" avere nodo "4" Come non visitato adiacente:

Nodo "4" è ora contrassegnato come visitato e aggiunto alla coda. Ora non abbiamo più nodi non visitati. Tuttavia, secondo il algoritmo, otterremo tutto nodi non visitati e continuare a rimuovere il nodo dalla coda secondo la procedura. Il programma finirà quando la coda diventa vuoto.

Implettiamo un esempio per verificare come funziona la prima ricerca JavaScript.

Come implementare la prima ricerca di ricerca in JavaScript

Per implementare la prima ricerca di ricerca in JavaScript, prima di tutto creeremo un grafico:

Lascia il grafico;

Il grafico sopra dato che viene utilizzato per illustrare la prima ricerca "5" nodi. Quindi, qui definiremo "5" nodi:

nodi const = 5;

Ora crea un file Array "Visited []" che verrà utilizzato per archiviare nodi visitati e il lunghezza di questo array sarà impostato in base al numero di nodi:

let visited = new Array (nodi);

Successivamente, definiremo il "CreateGraph ()" Funzionare allo scopo di creare un grafico e aggiungere nodi ad esso. Poi il "per" Loop eseguirà fino alla lunghezza del grafico. All'interno del ciclo, c'è un array bidimensionale che viene utilizzato per rappresentare i bordi del grafico inizializzati con "0":

const creategraph = (nodes) =>
grafico = nuovo array (nodi);
per (let i = 0; i < graph.length; i++)
Grafico [i] = nuovo array (nodi);
per (let i = 0; i < graph.length; i++)
per (let j = 0; j < graph[i].length; j++)
Grafico [i] [j] = 0;


;

Quindi definiremo il "Addge ()" funzione che accetta due argomenti "A" e "B". Questa funzione controllerà il bordo tra due nodi. Se si trova un bordo tra due nodi, allora il Funzione "Addge ()" sostituirà il "0" voce con "1" Nel grafico creato (array bidimensionale). Inoltre, aggiungendo "1" indica che l'argomento dei nodi passati ha un vantaggio tra loro:

const addge = (a, b) =>
per (let i = 0; i < graph.length; i++)
per (let j = 0; j < graph[i].length; j++)
if (i === a && j === b)
Grafico [i] [j] = 1;
Grafico [j] [i] = 1;

Ora definiremo il "BIHETHFIRSTSEARCH ()" funzione. Innanzitutto, creeremo un vuoto "coda". All'inizio, tutti i nodi non sono visitati, quindi sono contrassegnati come falsi con a "Visitato [i] = falso" dichiarazione. Quindi, selezioneremo l'avvio "nodo" che viene passato come argomento al "BIHETHFIRSTSEARCH ()" funzione e contrassegnarlo visitato. IL "coda.spingere()" Il metodo spingerà il "nodo" in coda quindi il "Mentre" Loop eseguirà fino alla lunghezza della coda. Questo ciclo controllerà i bordi del "CurrentNode" con il nodo rimanente.

Dentro il Loop "per", il aggiunto Condizione "if" "[CurrentNode] [j] === 1" controllerà i bordi tra il "CurrentNode" e il restante "J" nodi. Nel caso in cui entrambi i nodi abbiano un bordo tra loro e il corrispondente Nodo "j" non è ancora visitato, quindi sarà contrassegnato come "Visitato" e spinto alla "coda":

const flionethFirstSearch = (nodo) =>
const queue = []; per (let i = 0; i < visited.length; i++)
visitato [i] = false;
visitato [node] = true;
coda.push (nodo);
mentre (coda.lunghezza)
let correnteNode = coda.spostare();
console.log ('visitando $ currentNode');
per (let j = 0; j < graph[currentNode].length; j++)
if (grafico [currentNode] [j] === 1 && visitato [j] === false)
visitato [j] = true;
coda.push (j);



;

Successivamente, chiameremo il Funzione "CreateGraph ()" e passare il "Nodi" Come argomento:

creategraph (nodi);

Dopo averlo fatto, specificare i bordi del nodo “0, 1, 2, 3” con il Funzione "Addge ()", Come dimostrato nel diagramma sopra dato:

Addge (0, 1);
Addge (0, 2);
Addge (0, 3);
Addge (1, 0);
Addge (1, 4);
Addge (2, 0);
Addge (2, 4);
Addge (3, 0);
Addge (3, 4);

Qui, "0" viene passato come nodo iniziale al Funzione bfs () che eseguirà l'ulteriore operazione:

BIHETHFIRSTSEARCH (0);

Metodo BFS () attraverserà i nodi grafici e uscirà i nodi visitati sulla console:

Erano tutte informazioni utili su Algoritmo di attraversamento di larghezza di ricerca In JavaScript. Scegli ulteriori ricerche, se necessario.

Conclusione

LAPERTHTH-FIRST RICERCA (BFS) è un attraversamento algoritmo Questo è usato per Ricerca o attraversare il livello della struttura dei dati dell'albero o grafico per livello. Prima di passare al nodo per bambini Del livello di profondità successiva, visita ogni nodo che esiste al profondità attuale. In questo articolo, abbiamo discusso brevemente dell'algoritmo JavaScript di attrazione di ricerca di larghezza prima e sta lavorando con l'aiuto di un esempio adatto.