Bei der Breitensuche werden keine Warteschlangen verwendet

Breadth First, Look (BFS) ist eine Graph-Traversal-Berechnung, mit der das Zentrum in der Breitenbewegung in einem Diagramm untersucht wird. Die normale Verwendung von BFS nutzt die Leitungsinformationsstruktur, um eingehende Hubs zu verfolgen. Unabhängig davon ist es denkbar, andere Informationsstrukturen zu nutzen, um BFS durchzuführen, ohne explizite Verbindungen zu verwenden.

Eine alternative Möglichkeit, BFS ohne Kabel zu implementieren, besteht darin, zwei Cluster oder Datensätze zu verwenden: einen für den Hub auf der aktuellen Ebene, der untersucht wird, und einen für den Hub auf der nächsten Ebene, der untersucht werden soll. Die aktuelle Ebenenliste enthält zunächst das Quellzentrum.

Die Berechnung hebt zuerst die aktuelle Levelliste hervor und geht zu jedem Hub. Für jeden durchlaufenen Hub werden die benachbarten Hubs überprüft. Wenn ein benachbarter Hub nicht besucht wird, wird er als besucht markiert und zur Liste der anderen Ebenen hinzugefügt. Das Handle wird fortgesetzt, bis alle Hubs in der aktuellen Ebenenliste passiert wurden.

Sobald die aktuelle Ebenenliste vollständig durchlaufen ist, wird die Berechnung mit einer anderen Ebenenliste fortgesetzt und der Weg zum Hub erneut gehasht und auf die nächste Ebenenliste zugegriffen. Diese Vorbereitung wird fortgesetzt, bis keine nicht besuchten Knoten mehr vorhanden sind.

Anwendungsmethode

Breite-zuerst-Ansatz

Breite-zuerst-Ansatz

Der BFS-Algorithmus startet vom Quell-Hub, untersucht seine Nachbarn und wechselt zuletzt zu einer anderen Ebene von Nachbarn. Nutzen Sie die Linieninformationsstruktur, um den Überblick über die von Ihnen besuchten Hubs zu behalten. In jedem Zyklus besucht die Berechnung einen Hub, markiert ihn als abgeschlossen und stellt nicht besuchte benachbarte Hubs in die Warteschlange. Diese Vorbereitung wird fortgesetzt, bis alle erreichbaren Zentren besucht wurden.

Der Code initialisiert einen Vektor adj, um die Infektionsliste des Diagramms darzustellen. Jede Vektordatei wird mit einem Mittelpunkt verglichen und jeder aufgezeichnete Wert enthält benachbarte Mittelpunkte. Eine BFS-Durchquerung wird von einem BFS-Job durchgeführt, der den Quell-Hub, die Anzahl der Hubs N, den durch den Hub verlaufenden Vektor vis, einen separaten dp und den Vektor v verwendet, der zum Verfolgen der zu besuchenden Hubs verwendet wird. Der bfsTraversal-Job initialisiert den verschwundenen Hub, löscht die Vektoren und ruft dann den BFS-Job auf, um die Traversierung durchzuführen.

Algorithmus

• Erstellen Sie eine Infektionslistendarstellung des Diagramms.

• Initialisieren Sie eine Zeile, um den Hub zu speichern, auf den zugegriffen werden soll.

• Initialisieren Sie den verschwindenden Cluster, um verschwindende Knoten zu verfolgen.

• Initialisieren Sie den Löschcluster, um vom Quell-Hub gelöschte Inhalte auf jedem Hub zu speichern. Setzen Sie das Trennzeichen des Quell-Hubs auf 0.

• Stellen Sie den Quell-Hub in die Warteschlange und prüfen Sie, ob darauf zugegriffen wurde.

• Obwohl die Pipeline nicht gereinigt werden kann, gehen Sie bitte wie folgt vor:

• Entfernen Sie den Hub an der Spitze der Warteschlange. Gehen Sie für jeden Nachbar-Hub, der aus der Warteschlange entfernt und noch nicht durchlaufen wurde, wie folgt vor: Stellen Sie den Nachbar-Hub in die Warteschlange. Markieren Sie benachbarte Hubs als besucht. Die Löschung des Nachbar-Hubs wurde aktualisiert, um die Löschung des Hubs aus der Warteschlange zu entfernen (ebenfalls 1).

• Wiederholen Sie Schritt 6, bis die Zeile leer ist.

• Nachdem die BFS-Durchquerung abgeschlossen ist, enthält ein separater Cluster die Intervalle vom Quellknoten zu allen anderen Zentren im Diagramm.

• (Optional) Sie können auch den übergeordneten Hub jedes Hubs in einem BFS-Traversal verfolgen, um auf einfachste Weise vom Quell-Hub zu allen anderen Hubs zu gelangen.

Beispiel

#include <iostream>
#include <queue>
#include <unordered_set>
using namespace std;

void bfsTraversal(int adjacencyList[][2], int numVertices, int source) {
   bool visited[numVertices + 1] = {false};
   int distances[numVertices + 1] = {0};

   queue<int> vertices;
   vertices.push(source);
   visited[source] = true;

   while (!vertices.empty()) {
      int node = vertices.front();
      cout << node << ", ";
      vertices.pop();

      for (int i = 0; i < 2; i++) {
         int next = adjacencyList[node][i];
            
         if (!visited[next]) {
            vertices.push(next);
            distances[next] = distances[node] + 1;
            visited[next] = true;
         }
      }
   }
}

int main() {
    int adjacencyList[][2] = {{0, 0}, {1, 2}, {3, 4}, {0, 0}, {0, 0}};
    int numVertices = 4;
    int source = 2;

    bfsTraversal(adjacencyList, numVertices, source);

    return 0;
}

Ausgabe

2,3,4,0

Beispiel

#include <iostream>
#include <vector>
using namespace std;

void bfsTraversal(vector<vector<int>>& adjacencyList, int N, int source) {
    vector<bool> visited(N + 1, false);
    vector<int> distances(N + 1, 0);
    vector<int> vertices;

    vertices.push_back(source);
    visited[source] = true;

    int curr = 0;
    while (curr < vertices.size()) {
        int node = vertices[curr];
        cout << node << ", ";

        for (int i = 0; i < adjacencyList[node].size(); i++) {
            int next = adjacencyList[node][i];

            if (!visited[next]) {
                vertices.push_back(next);
                distances[next] = distances[node] + 1;
                visited[next] = true;
            }
        }

        curr++;
    }

    cout << "\nDistances from source " << source << ":\n";
    for (int i = 1; i <= N; i++) {
        cout << "Node " << i << ": " << distances[i] << endl;
    }
}

int main() {
    int N = 8;
    vector<vector<int>> adjacencyList(N + 1);
    adjacencyList[0] = {1, 2};
    adjacencyList[1] = {2};
    adjacencyList[2] = {0, 3};
    adjacencyList[3] = {3};
    adjacencyList[4] = {5};
    adjacencyList[5] = {6, 7};
    adjacencyList[6] = {};
    adjacencyList[7] = {};
    adjacencyList[8] = {};

    int source = 5;

    bfsTraversal(adjacencyList, N, source);

    return 0;
}

Ausgabe

5, 6, 7, 
Distances from source 5:
Node 1: 0
Node 2: 0
Node 3: 0
Node 4: 0
Node 5: 0
Node 6: 1
Node 7: 1
Node 8: 0

Fazit

In diesem Artikel werden Berechnungen der Breitensuche (BFS) ohne Verwendung von Zeileninformationsstrukturen erläutert. BFS-Berechnungen werden normalerweise verwendet, um ausgehend von einem bestimmten Quellzentrum Schritt für Schritt durch ein Diagramm zu navigieren. Typischerweise wird eine Route zum Speichern von Hubs verwendet, zu denen man reisen möchte. Unabhängig davon untersucht dieser Artikel einen alternativen Ansatz, der einfache Listen oder Cluster verwendet, um die nächste Ebene von Hubs zu speichern.

Diese selektive Verwendung vervollständigt das umfassende Studium von Diagrammen. In diesem Artikel werden die Schritte der BFS-Berechnung nachgezeichnet, z. B. die Initialisierung von Infektionsdatensätzen, die Verwaltung von Go-to- und Separation-Clustern sowie die Verwendung von Kreisen zur Hervorhebung zentraler Ebenen. Es enthält außerdem C-Code-Anweisungen, die die BFS-Durchquerung veranschaulichen, ohne eine einzige Zeile zu verwenden. Der Code untersucht das Diagramm genau, druckt die BFS-Traversalpermutation und berechnet die Entfernung vom Quell-Hub zu allen anderen Knoten. Insgesamt liefert dieser Artikel eine klare Erklärung und praktikablen Einsatz von BFS-Berechnungen ohne die Verwendung von Linien und demonstriert einen alternativen Ansatz für die Navigation in Diagrammen in einer Breitenorientierung.

Das obige ist der detaillierte Inhalt vonBei der Breitensuche werden keine Warteschlangen verwendet. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!