Breedte-eerst zoeken (BFS) En Diepte-eerst zoeken (DFS) zijn twee fundamentele algoritmen die worden gebruikt voor het doorkruisen of doorzoeken van grafieken en bomen. Dit artikel behandelt het fundamentele verschil tussen breedte-eerst zoeken en diepte-eerst zoeken.

Verschil tussen BFS en DFS
Breedte-eerst zoeken (BFS) :
BFS, breedte-eerst zoeken, is een op hoekpunten gebaseerde techniek voor het vinden van het kortste pad in de grafiek. Het maakt gebruik van een Uitgang:
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 * bijvoeglijk naamwoord; publiek: Grafiek(int V); // Constructor // functie om een rand toe te voegen aan de grafiek void addEdge(int v, int w); // drukt BFS-traversal af vanaf de void BFS van een bepaalde bron (int s); }; Grafiek::Grafiek(int V) { this->V = V; adj = nieuwe lijst [V]; } void Graph::addEdge(int v, int w) { adj[v].push_back(w); // Voeg w toe aan de lijst van v. } void Graph::BFS(int s) {// Markeer alle hoekpunten als niet bezocht bool* bezocht = nieuwe bool[V]; voor (int i = 0; ik< V; i++) visited[i] = false; // Create a queue for BFS list wachtrij; // Markeer het huidige knooppunt als bezocht en plaats het in de wachtrij bezocht[s] = waar; wachtrij.push_back(s); // 'i' wordt gebruikt om alle aangrenzende hoekpunten van een // hoekpuntenlijst op te halen ::iterator ik; // Maak een mapping van gehele getallen naar karakters char map[6] = { 'A', 'B', 'C', 'D', 'E', 'F '}; while (!queue.empty()) {// Haal een hoekpunt uit de wachtrij en druk het af s = wachtrij.front(); uit<< 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 van aangrenzende lijsten } // Functie om een rand toe te voegen aan de grafiek addEdge(v, w) { this.adj[v].push(w); // Voeg w toe aan de lijst van v. } // Functie om BFS-traversal uit te voeren vanaf de BFS(s) van een bepaalde bron {// Markeer alle hoekpunten als niet bezocht let visit = new Array(this.V).fill(false); // Maak een wachtrij voor BFS let wachtrij = []; // Markeer het huidige knooppunt als bezocht en plaats het in de wachtrij bezocht[s] = waar; wachtrij.push(s); // Mapping van gehele getallen naar karakters laat map = ['A', 'B', 'C', 'D', 'E', 'F']; while (queue.length> 0) {// Haal een hoekpunt uit de wachtrij en druk het af s = wachtrij.shift(); console.log(kaart[s] + ''); // Gebruik de mapping om het originele label af te drukken // Haal alle aangrenzende hoekpunten op van de uit de wachtrij gehaalde hoekpunten // Als een aangrenzend punt niet is bezocht, markeer het dan als bezocht // en zet het in de wachtrij voor (laat ik dit.adj[s ]) { if (!bezocht[i]) { wachtrij.push(i); bezocht[i] = waar; } } } } } // Hoofdfunctie functie main() {// Maak een grafiek uit het diagram /* 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('Breedte eerste traversal is: '); g.BFS(0); // Start BFS vanaf A (0) } // Voer de hoofdfunctie main();>
Uitvoer
Breadth First Traversal is: A B C D E F>
Diepte eerste zoekopdracht (DFS) :
DFS, Diepte eerste zoekopdracht , is een op randen gebaseerde techniek. Het maakt gebruik van de Uitgang:
A, B, C, D, E, F>
Verschil tussen BFS en DFS:
Parameters | BFS | DFS |
---|---|---|
Betekent | BFS staat voor Breadth First Search. | DFS staat voor Depth First Search. |
Data structuur | BFS (Breadth First Search) gebruikt de wachtrijgegevensstructuur om het kortste pad te vinden. | DFS (Depth First Search) maakt gebruik van de Stack-datastructuur. |
Definitie | BFS is een traversale aanpak waarbij we eerst door alle knooppunten op hetzelfde niveau lopen voordat we naar het volgende niveau gaan. | DFS is ook een traversale benadering waarbij de traverse begint bij het hoofdknooppunt en zo ver mogelijk door de knooppunten gaat totdat we het knooppunt bereiken zonder onbezochte nabijgelegen knooppunten. |
Conceptueel verschil | BFS bouwt de boom niveau voor niveau op. | DFS bouwt de boom subboom voor subboom op. |
Gebruikte aanpak | Het werkt volgens het concept van FIFO (First In First Out). | Het werkt volgens het concept van LIFO (Last In First Out). |
Geschikt voor | BFS is geschikter voor het zoeken naar hoekpunten dichter bij de gegeven bron. | DFS is geschikter als er oplossingen buiten de bron zijn. |
Toepassingen | BFS wordt gebruikt in verschillende toepassingen, zoals bipartiete grafieken, kortste paden, enz. | DFS wordt gebruikt in verschillende toepassingen, zoals acyclische grafieken en het vinden van sterk verbonden componenten enz. |
Zie ook BFS versus DFS voor binaire boom voor de verschillen voor een binaire boomtraversal.