logo

Unterschied zwischen BFS und DFS

Breitensuche (BFS) Und Tiefensuche (DFS) sind zwei grundlegende Algorithmen, die zum Durchlaufen oder Durchsuchen von Diagrammen und Bäumen verwendet werden. Dieser Artikel behandelt den grundlegenden Unterschied zwischen der Breitensuche und der Tiefensuche.

bfs-vs-dfs-(1)

Unterschied zwischen BFS und DFS



Breitensuche (BFS) :

BFS, Breitensuche, ist eine scheitelpunktbasierte Technik zum Finden des kürzesten Pfades im Diagramm. Es verwendet a Ausgabe:

A, B, C, D, E, F>

Code:

C++
#include  #include  using namespace std; // This class represents a directed graph using adjacency // list representation class Graph {  int V; // No. of vertices  // Pointer to an array containing adjacency lists  list * adj; public: Graph(int V); // Konstruktor // Funktion zum Hinzufügen einer Kante zum Diagramm void addEdge(int v, int w);  // druckt die BFS-Durchquerung aus einer bestimmten Quelle s void BFS(int s); }; Graph::Graph(int V) { this->V = V;  adj = neue Liste [V]; } void Graph::addEdge(int v, int w) { adj[v].push_back(w); // w zur Liste von v hinzufügen. } void Graph::BFS(int s) { // Alle Eckpunkte als nicht besucht markieren bool* besuchte = new bool[V];  für (int i = 0; i< V; i++)  visited[i] = false;  // Create a queue for BFS  list Warteschlange;  // Den aktuellen Knoten als besucht markieren und in die Warteschlange einreihen besuchte[s] = true;  queue.push_back(s);  // 'i' wird verwendet, um alle benachbarten Scheitelpunkte einer // Scheitelpunktliste abzurufen ::iterator i;  // Eine Zuordnung von Ganzzahlen zu Zeichen erstellen char map[6] = { 'A', 'B', 'C', 'D', 'E', 'F ' };  while (!queue.empty()) { // Einen Scheitelpunkt aus der Warteschlange entfernen und ausdrucken s = queue.front();  cout<< map[s] << ' '; // Use the mapping to print  // the original label  queue.pop_front();  // Get all adjacent vertices of the dequeued vertex  // s If a adjacent has not been visited, then mark  // it visited and enqueue it  for (i = adj[s].begin(); i != adj[s].end(); ++i) {  if (!visited[*i]) {  queue.push_back(*i);  visited[*i] = true;  }  }  } } int main() {  // Create a graph given in the diagram  /* A  /   B C  / /   D E F  */  Graph g(6);  g.addEdge(0, 1);  g.addEdge(0, 2);  g.addEdge(1, 3);  g.addEdge(2, 4);  g.addEdge(2, 5);  cout << 'Breadth First Traversal is: ';  g.BFS(0); // Start BFS from A (0)  return 0; }>
Python
from collections import deque # This class represents a directed graph using adjacency list representation class Graph: def __init__(self, V): self.V = V # No. of vertices self.adj = [[] for _ in range(V)] # Adjacency lists # Function to add an edge to graph def addEdge(self, v, w): self.adj[v].append(w) # Add w to v’s list # Prints BFS traversal from a given source s def BFS(self, s): # Mark all the vertices as not visited visited = [False] * self.V # Create a queue for BFS queue = deque() # Mark the current node as visited and enqueue it visited[s] = True queue.append(s) # Create a mapping from integers to characters mapping = ['A', 'B', 'C', 'D', 'E', 'F'] while queue: # Dequeue a vertex from queue and print it s = queue.popleft() # Use the mapping to print the original label print(mapping[s], end=' ') # Get all adjacent vertices of the dequeued vertex s # If an adjacent has not been visited, then mark it visited # and enqueue it for i in self.adj[s]: if not visited[i]: queue.append(i) visited[i] = True if __name__ == '__main__': # Create a graph given in the diagram # A # /  # B C # / /  # D E F g = Graph(6) g.addEdge(0, 1) g.addEdge(0, 2) g.addEdge(1, 3) g.addEdge(2, 4) g.addEdge(2, 5) print('Breadth First Traversal is: ', end='') g.BFS(0) # Start BFS from A (0)>
JavaScript
// This class represents a directed graph using adjacency list representation class Graph {  constructor(V) {  this.V = V; // No. of vertices  this.adj = new Array(V).fill(null).map(() =>[]); // Array von Adjazenzlisten } // Funktion zum Hinzufügen einer Kante zum Diagramm addEdge(v, w) { this.adj[v].push(w); // w zur Liste von v hinzufügen.  } // Funktion zum Durchführen einer BFS-Traversierung von einer bestimmten Quelle aus s BFS(s) { // Markieren Sie alle Scheitelpunkte als nicht besucht let besuchte = new Array(this.V).fill(false);  // Eine Warteschlange für BFS erstellen let queue = [];  // Den aktuellen Knoten als besucht markieren und in die Warteschlange einreihen besuchte[s] = true;  queue.push(s);  // Zuordnung von Ganzzahlen zu Zeichen let map = ['A', 'B', 'C', 'D', 'E', 'F'];  while (queue.length> 0) { // Einen Scheitelpunkt aus der Warteschlange entfernen und ausdrucken s = queue.shift();  console.log(map[s] + ' '); // Verwenden Sie die Zuordnung, um das Originaletikett zu drucken // Holen Sie sich alle benachbarten Scheitelpunkte der aus der Warteschlange entfernten Scheitelpunkte s // Wenn ein angrenzender Scheitelpunkt nicht besucht wurde, markieren Sie ihn als besucht // und stellen Sie ihn in die Warteschlange für (sei i von this.adj[s ]) { if (!visited[i]) { queue.push(i);  besuchte[i] = wahr;  } } } } } // Hauptfunktion function main() { // Erstelle einen im Diagramm angegebenen Graphen /* A /  B C / /  D E F */ let g = new Graph(6);  g.addEdge(0, 1);  g.addEdge(0, 2);  g.addEdge(1, 3);  g.addEdge(2, 4);  g.addEdge(2, 5);  console.log('Breadth First Traversal ist: ');  g.BFS(0); // BFS von A (0) starten } // Hauptfunktion ausführen main();>

Ausgabe
Breadth First Traversal is: A B C D E F>

Tiefensuche (DFS) :

DFS, Tiefensuche ist eine kantenbasierte Technik. Es nutzt die Ausgabe:



A, B, C, D, E, F>

Unterschied zwischen BFS und DFS:

ParameterBFSDFS
Steht fürBFS steht für „Breadth First Search“.DFS steht für Depth First Search.
DatenstrukturBFS (Breadth First Search) verwendet die Warteschlangendatenstruktur, um den kürzesten Pfad zu finden.DFS (Depth First Search) verwendet die Stack-Datenstruktur.
DefinitionBFS ist ein Traversal-Ansatz, bei dem wir zunächst alle Knoten auf derselben Ebene durchlaufen, bevor wir zur nächsten Ebene übergehen.DFS ist auch ein Traversal-Ansatz, bei dem die Traverse am Wurzelknoten beginnt und so weit wie möglich durch die Knoten verläuft, bis wir den Knoten ohne unbesuchte nahegelegene Knoten erreichen.
Konzeptioneller UnterschiedBFS baut den Baum Ebene für Ebene auf.DFS baut den Baum Teilbaum für Teilbaum auf.
Ansatz verwendetEs basiert auf dem FIFO-Konzept (First In First Out).Es basiert auf dem LIFO-Konzept (Last In First Out).
Passend fürBFS eignet sich besser für die Suche nach Scheitelpunkten, die näher an der angegebenen Quelle liegen.DFS ist besser geeignet, wenn es Lösungen außerhalb der Quelle gibt.
AnwendungenBFS wird in verschiedenen Anwendungen wie bipartiten Graphen, kürzesten Pfaden usw. verwendet.DFS wird in verschiedenen Anwendungen wie azyklischen Graphen und der Suche nach stark verbundenen Komponenten usw. verwendet.

Bitte sehen Sie auch BFS vs. DFS für Binärbaum für die Unterschiede für eine Binary Tree Traversal.