Bredde-første søk Traversal i JavaScript

I denne moderne teknologiske verden er vi pålagt å bruke teknikker for å krysse trærne programmatisk, selv om datamaskinen vår har et brukervennlig grensesnitt for å surfe over vårt filtre, for dette formålet Bredde-søk (BFS) er den mest nyttige algoritmen.

Bredde-første søk er en kryssende algoritme som brukes til Søker eller krysser tre- eller grafdataene Strukturlag for lag. Før du går videre til barneknuten på neste dybdivå, besøker den hver node som finnes på dagens dybde.

Denne artikkelen vil forklare hvordan du skal kjøre Bredde-første søkealgoritme Bruke et passende eksempel. Så la oss starte

Hvordan bredde-første søkealgoritme fungerer i JavaScript

Arbeidet med bredde-første søkealgoritme inneholder følgende trinn:

• Velge en node og lage en kø med alle det nabo noder.
• Fjerne de noder fra køen som blir besøkt og merk dem.
• Legg til alle av det naboknuter i køen.
• Gjenta Inntil køen blir tømme eller du når målet ditt.

Hvis en node blir revidert før den ikke ble merket som besøkt, vil programmet bli stoppet. Derfor, Mark Nodes som besøkt, og da blir det ikke søkt igjen.

Implementering av bredde-første søket Traversal-algoritme

Bredde-første søk krysser trær fra venstre til høyre, beveger seg deretter fra topp til bunn (Foreldreknute til barneknute). Sikre at alle nodene som er til stede på nåværende dybde blir besøkt.

La oss nå se på et lite eksempel for å forstå BFS Traversal Works. Her har den gitte understyrte grafen 5 noder “0”, “1”, “2”, “3” og “4”:

Vi vil nå bruke denne Traversal -algoritmen på den spesifiserte grafen.

Trinn 1: Initialisering av køen

Først av alt må vi Initialiser køen “Q”:

Trinn 2: Velg Startnode

Deretter velger vi startnoden. For dette formålet vil vi velge “0” som startende node og Merk det som besøkt:

Trinn 3: Uvisitert tilstøtende noder med startnode

Startnode er besøkte og merket; Nå vil vi sjekke det tilstøtende noder. I illustrasjonen nedenfor, Starter node “0” har Tre uvisede tilstøtende noder “1”, “2” og “3”; Imidlertid vil vi velge node "1" På grunn av sekvens av telling. Deretter, merke det som besøkte og Legg til det til kø:

Nå, den uvisnet Node av “0” er “2”, som også er Merket som besøkt og lagt til i køen:

Da vil vi besøk den siste uvisede tilstøtende noden, som er “3”, merket det som besøkte og enqueue det:

Trinn 4: Dequeue startnoden

Nå vår valgte startnode “0” har ingen uovertruffelige tilstøtende noder, så vi fjerner køen og søker etter noden "1":

Trinn 5: Kontroller den uvisede ved siden av noden “1”

På dette tidspunktet, node "1" har node “4” som dets uvisede ved siden av:

Node “4” er nå merket som besøkte og lagt til til køen. Nå har vi ikke mer uvisede noder. Imidlertid, ifølge algoritme, Vi får alle uvisede noder og fortsett å fjerne noden fra køen i henhold til prosedyren. Programmet vil avsluttes når køen blir tømme.

La oss implementere et eksempel for å sjekke hvordan bredde-første søk fungerer i JavaScript.

Hvordan implementere bredde-første søkekryss i JavaScript

For å implementere bredde-første søk gjennomganger i JavaScript, vil vi først lage en graf:

La grafen;

Den ovennevnte grafen som brukes til å illustrere bredden-første søket har “5” noder. Så her vil vi definere “5” noder:

const noder = 5;

Nå, lage en “Besøkt []” Array som vil bli brukt til å lagre besøkte noder og lengde av denne matrisen vil bli satt i henhold til antall noder:

la besøkte = ny matrise (noder);

Deretter vil vi definere “CreateGraph ()” funksjon med det formål å lage en graf og legge til noder til den. Og så "til" Loop vil utføre til lengden på grafen. Inne “0”:

const creategraph = (noder) =>
graf = ny matrise (noder);
for (la i = 0; i < graph.length; i++)
graf [i] = ny matrise (noder);
for (la i = 0; i < graph.length; i++)
for (la j = 0; j < graph[i].length; j++)
graf [i] [j] = 0;


;

Deretter vil vi definere “AddEdge ()” funksjon som godtar to argumenter “A” og “B”. Denne funksjonen vil sjekke kanten mellom to noder. Hvis en kant finnes mellom to noder, så er “AddEdge ()” -funksjon vil erstatte “0” oppføring med “1” I den opprettede grafen (todimensjonal matrise). Også legge til "1" indikerer at det passerte noder -argumentet har en fordel mellom seg:

const addEdge = (a, b) =>
for (la i = 0; i < graph.length; i++)
for (la j = 0; j < graph[i].length; j++)
if (i === a && j === b)
graf [i] [j] = 1;
graf [j] [i] = 1;

Nå vil vi definere “BreadthFirstSearch ()” funksjon. Først vil vi lage en tom "kø". Ved starten er alle nodene uovertruffen, så de er merket som falske med en “Besøkt [i] = falsk” uttalelse. Deretter vil vi velge start “Node” som blir gitt som argument til “BreadthFirstSearch ()” funksjon og merk det besøkte. De "kø.trykk()" metoden vil skyve “Node” til køen deretter "samtidig som" Loop vil utføre til lengden på køen. Denne sløyfen vil sjekke kantene på “CurrentNode” med den gjenværende noden.

Inne i “For” -sløyfe, den tilsatte “Hvis” tilstand “[CurrentNode] [j] === 1” vil sjekke kantene mellom “CurrentNode” og de resterende “J” noder. I tilfelle, hvis begge nodene har en kant mellom seg og tilsvarende “J” -noden er ikke besøkt ennå, da vil det bli merket som “Besøkt” og presset til “køen”:

const BreadThFirstSearch = (node) =>
const kø = []; for (la i = 0; i < visited.length; i++)
besøkt [i] = falsk;
Besøkt [Node] = True;
kø.push (node);
mens (kø.lengde)
La CurrentNode = kø.skifte();
konsoll.log ('Besøk $ currentNode');
for (la j = 0; j < graph[currentNode].length; j++)
if (graf [currentNode] [j] === 1 && besøkte [j] === falsk)
besøkt [j] = sant;
kø.Push (J);



;

Deretter vil vi ringe “CreateGraph ()” -funksjon og passere “Noder” som argument:

createGraph (noder);

Etter å ha gjort det, spesifiser kantene på noden “0, 1, 2, 3” med “AddEdge ()” -funksjon, Som demonstrert i det ovennevnte diagrammet:

addEdge (0, 1);
addEdge (0, 2);
AddEdge (0, 3);
addEdge (1, 0);
AddEdge (1, 4);
addEdge (2, 0);
AddEdge (2, 4);
addEdge (3, 0);
AddEdge (3, 4);

Her, “0” sendes som startnode til BFS () -funksjon som vil utføre den videre driften:

BredthFirstSearch (0);

BFS () -metode vil krysse grafnodene og sende ut de besøkte nodene på konsollen:

Det var alt nyttig informasjon om Bredde-første søk Traversal algoritme I JavaScript. Gå for videre forskning om nødvendig.

Konklusjon

Bredde-første søk (BFS) er en kryssende algoritme som brukes til Søker eller krysser treet eller grafens datastruktur lag for lag. Før du går videre til Barneknute Av neste dybdivå besøker den hver node som finnes på Gjeldende dybde. I denne artikkelen har vi kort diskut.