Breite-First-Suchtraversal in JavaScript

In dieser modernen technologischen Welt müssen wir Techniken zum programmgesteuerten Bäumen verwenden, obwohl unser Computer über eine benutzerfreundliche Schnittstelle zum Durchsuchen unseres Dateibaum.

Breite-First-Suche ist ein Durchqueren Algorithmus das wird verwendet für Suchen oder Durchqueren der Baum- oder Grafikdaten Strukturschicht für Schicht. Bevor Sie mit dem Kinderknoten der nächsten Tiefenebene übergehen, besucht er jeden Knoten, der in der aktuellen Tiefe existiert.

In diesem Artikel wird erklärt, wie man das ausführt BREATH-First-Suchalgorithmus Verwenden eines geeigneten Beispiels. So lass uns anfangen

Wie die Suchalgorithmus für Breite in JavaScript funktioniert

Die Funktionsweise des Suchalgorithmus zur Breite zuerst umfasst die folgenden Schritte:

• Wählen ein Knoten und erstellen a Warteschlange mit all seinen Nachbar Knoten.
• Entfernen diese Knoten Aus der Warteschlange, die besucht werden und sie markieren.
• Hinzufügen all seine Nachbarknoten in der Warteschlange.
• Wiederholen Bis die Warteschlange wird leer oder Sie erreichen Ihr Ziel.

Wenn ein Knoten überarbeitet wird, bevor er nicht als besucht markiert wurde, wird das Programm gestoppt. Daher werden die Knoten wie besucht und dann werden es dann nicht wieder durchsucht.

Implementierung des Breit-First-Suchtraversalalgorithmus

Breite-First-Suche durchquert Bäume von links nach rechts und bewegt sich dann von oben nach unten (Elternknoten zu Kinderknoten). Stellen Sie sicher, dass alle in der aktuellen Tiefe vorhandenen Knoten besucht werden.

Schauen wir uns nun ein kleines Beispiel an, um das zu verstehen BFS Traversalwerke. Hier hat die angegebene ungerichtete Grafik 5 Knoten "0", "1", "2", "3" und "4":

Wir werden diesen Traversalalgorithmus nun im angegebenen Diagramm verwenden.

Schritt 1: Initialisierung der Warteschlange

Erstens müssen wir Initialisieren Sie die Warteschlange "Q":

Schritt 2: Wählen Sie den Knoten des Knotens aus

Als nächstes werden wir den Startknoten auswählen. Zu diesem Zweck werden wir auswählen "0" als Startknoten und Markieren Sie es als besucht:

Schritt 3: Nicht besuchte benachbarte Knoten des Startknotens

Startknoten ist besucht und markiert; Jetzt werden wir seine überprüfen benachbarte Knoten. In der folgenden Abbildung, Starten des Knotens "0" hat Drei nicht besuchte benachbarte Knoten „1“, „2“ und „3“; Wir werden jedoch den Knoten wählen "1" wegen dem Reihenfolge des Zählens. Dann, markieren es als hat besucht Und hinzufügen es zum Warteschlange:

Jetzt die nicht besucht Knoten von "0" ist "2", was auch ist markiert wie besucht und zur Warteschlange hinzugefügt:

Dann werden wir besuchen der letzte nicht besuchte benachbarte Knoten, nämlich "3", markierte es als besucht und erleichtert es:

Schritt 4: Dequeue den Startknoten

Jetzt unser ausgewählter Startknoten "0" Hat keine nicht besuchten angrenzenden Knoten, daher entfernen wir die Warteschlange und suchen nach dem Knoten "1":

Schritt 5: Überprüfen Sie den nicht besuchten Nebenknoten „1“

An diesem Punkt Knoten "1" Knoten haben "4" als nicht besuchte angrenzend:

Knoten "4" ist jetzt als markiert als besucht und hinzugefügt zur Warteschlange. Jetzt haben wir nicht mehr nicht besuchte Knoten. Nach Ansicht der Algorithmus, Wir werden alle erhalten nicht besuchte Knoten und entfernen Sie den Knoten weiter aus der Warteschlange gemäß der Prozedur. Das Programm endet, wenn die Warteschlange wird leer.

Lassen Sie uns ein Beispiel implementieren, um zu überprüfen JavaScript.

So implementieren Sie die Suchtraversal der Breite in JavaScript

Um die Suchtraversal der Breite in JavaScript zu implementieren, erstellen wir zunächst ein Diagramm:

Diagramm;

Das oben gegebene Diagramm, mit dem die Breite der ersten Suche veranschaulicht wird "5" Knoten. Also werden wir hier definieren "5" Knoten:

constknoten = 5;

Erstellen Sie jetzt eine "Besucht []" Array Das wird verwendet, um zu speichern besuchte Knoten und das Länge von diesem Array wird gemäß der Anzahl von festgelegt Knoten:

let besucht = neu Array (Knoten);

Als nächstes werden wir das definieren "CreateGraph ()" Funktion zum Erstellen eines Diagramms und zum Hinzufügen von Knoten zu ihm. Dann ist die "für" Die Schleife wird bis zur Länge des Diagramms ausgeführt. In der Schleife befindet sich ein zweidimensional "0":

const createGraph = (Knoten) =>
Graph = New Array (Knoten);
für (lass i = 0; i < graph.length; i++)
Graph [i] = Neuarray (Knoten);
für (lass i = 0; i < graph.length; i++)
für (lass j = 0; j < graph[i].length; j++)
Graph [i] [j] = 0;


;

Dann werden wir das definieren "Addgege ()" Funktion, die zwei Argumente akzeptiert "A und B". Diese Funktion überprüft die Kante zwischen zwei Knoten. Wenn zwischen zwei Knoten eine Kante gefunden wird, dann die "Addgege ()" Funktion wird die ersetzen "0" Eintrag mit "1" In der erstellten Grafik (zweidimensionales Array). Auch hinzufügen "1" Zeigt an, dass das Argument der bestandenen Knoten eine Kante dazwischen hat:

const addge = (a, b) =>
für (lass i = 0; i < graph.length; i++)
für (lass j = 0; j < graph[i].length; j++)
if (i === a && j === b)
Graph [i] [j] = 1;
Graph [j] [i] = 1;

Jetzt werden wir das definieren "BreadthfirstSearch ()" Funktion. Erstens werden wir eine leere erstellen "Warteschlange". Zu Beginn sind alle Knoten nicht besucht, so dass sie mit a als falsch markiert sind "Besucht [i] = false" Stellungnahme. Dann werden wir den Start auswählen "Knoten" das wird als Argument an die übergeben "BreadthfirstSearch ()" Funktion und markieren Sie es besucht. Der "Warteschlange.drücken()" Methode drückt die "Knoten" an die Warteschlange dann die "während" Die Schleife wird bis zur Länge der Warteschlange ausgeführt. Diese Schleife überprüft die Kanten der Ränder "CurrentNode" mit dem verbleibenden Knoten.

In der "Für" Schleife, das hinzugefügte "Wenn" Bedingung "[currentNode] [j] === 1" überprüft die Kanten zwischen den "CurrentNode" und die restlichen "J" Knoten. Im Fall, wenn beide Knoten eine Kante zwischen ihnen und den entsprechenden haben "J" Knoten wird noch nicht besucht, dann wird es als markiert als "Besucht" und in die "Warteschlange" gedrängt ":

const breadthfirstSearch = (Knoten) =>
const queue = []; für (let i = 0; i < visited.length; i++)
besucht [i] = false;
besucht [node] = true;
Warteschlange.Push (Knoten);
während (Warteschlange.Länge)
lass CurrentNode = Queue.Schicht();
Konsole.log ('besuchen $ currentNode');
für (lass j = 0; j < graph[currentNode].length; j++)
if (Graph [currentNode] [j] === 1 && besucht [j] === false)
besucht [j] = true;
Warteschlange.Push (j);



;

Als nächstes werden wir das anrufen "CreateGraph ()" Funktion und übergeben "Knoten" als Argument:

CreateGraph (Knoten);

Geben Sie danach die Kanten des Knotens „0, 1, 2, 3“ mit dem an "Addgege ()" Funktion, Wie im oben gegebenen Diagramm gezeigt:

hinzugefügt (0, 1);
hinzugefügt (0, 2);
hinzugefügt (0, 3);
hinzugefügt (1, 0);
hinzugefügt (1, 4);
hinzugefügt (2, 0);
hinzugefügt (2, 4);
hinzugefügt (3, 0);
hinzugefügt (3, 4);

Hier, "0" wird als Startknoten an die BFS () -Funktion die die weitere Operation durchführen:

BreadthfirstSearch (0);

BFS () Methode Durchquert die Graphenknoten und geben die besuchten Knoten auf der Konsole aus:

Das waren alles nützliche Informationen darüber Breite-First-Suchtraversalalgorithmus In JavaScript. Gehen Sie bei Bedarf weitere Recherchen.

Abschluss

Breite-First-Suche (BFS) ist ein Durchqueren Algorithmus das wird verwendet für Suchen oder Durchqueren der Baum- oder Grafikdatenstrukturschicht für Schicht. Bevor Sie weiterging zur Kinderknoten von der nächsten Tiefenebene besucht es jeden Knoten, der am vorhanden ist Aktuelle Tiefe. In diesem Artikel haben wir kurz den Breadth-First-Suchtraversal-JavaScript-Algorithmus und ihre Arbeit mit Hilfe eines geeigneten Beispiels erörtert.