Breadth-First Search (BFS) og Depth-First Search (DFS) er to grunnleggende algoritmer som brukes for å krysse eller søke i grafer og trær. Denne artikkelen dekker den grunnleggende forskjellen mellom Breadth-First Search og Depth-First Search.

Forskjellen mellom BFS og DFS
Breadth-First Search (BFS) :
BFS, Breadth-First Search, er en toppunktbasert teknikk for å finne den korteste veien i grafen. Den bruker en Produksjon:
A, B, C, D, E, F>
Kode:
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; offentlig: Graph(int V); // Konstruktør // funksjon for å legge til en kant til grafen void addEdge(int v, int w); // skriver ut BFS-traversal fra en gitt kilde s void BFS(int s); }; Graph::Graph(int V) { this->V = V; adj = ny liste [V]; } void Graph::addEdge(int v, int w) { adj[v].push_back(w); // Legg til w til vs liste. } void Graph::BFS(int s) { // Merk alle toppunktene som ikke besøkt bool* besøkt = new bool[V]; for (int i = 0; i< V; i++) visited[i] = false; // Create a queue for BFS list kø; // Merk gjeldende node som besøkt og legg den i kø[s] = true; kø.push_back(er); // 'i' vil bli brukt for å få alle tilstøtende toppunkter av en // toppunktliste ::iterator i; // Lag en tilordning fra heltall til tegn char map[6] = { 'A', 'B', 'C', 'D', 'E', 'F ' }; while (!queue.empty()) { // Sett et toppunkt i kø fra køen og skriv det ut 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 of adjacency lists } // Funksjon for å legge til en kant til grafen addEdge(v, w) { this.adj[v].push(w); // Legg til w til vs liste. } // Funksjon for å utføre BFS-traversal fra en gitt kilde s BFS(s) { // Merk alle toppunktene som ikke besøkt la besøkt = new Array(this.V).fill(false); // Opprett en kø for BFS la køen = []; // Merk gjeldende node som besøkt og legg den i kø[s] = true; queue.push(s); // Kartlegging fra heltall til tegn lar kartlegge = ['A', 'B', 'C', 'D', 'E', 'F']; while (queue.length> 0) { // Sett et toppunkt i kø fra køen og skriv det ut s = queue.shift(); console.log(kart[s] + ' '); // Bruk kartleggingen til å skrive ut den originale etiketten // Få alle tilstøtende hjørner av det dekøde toppunktet s // Hvis en tilstøtende ikke har blitt besøkt, merk den som besøkt // og still den i kø for (la i av dette.adj[s ]) { if (!besøkt[i]) { queue.push(i); besøkt[i] = sant; } } } } } // Hovedfunksjon funksjon main() { // Lag en graf gitt i diagrammet /* A / B C / / D E F */ la 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('Bredth First Traversal er: '); g.BFS(0); // Start BFS fra A (0) } // Kjør hovedfunksjonen main();>
Produksjon
Breadth First Traversal is: A B C D E F>
Depth First Search (DFS) :
DFS, Dybde første søk , er en kantbasert teknikk. Den bruker Produksjon:
A, B, C, D, E, F>
Forskjellen mellom BFS og DFS:
Parametere | BFS | DFS |
---|---|---|
Står for | BFS står for Breadth First Search. | DFS står for Depth First Search. |
Data struktur | BFS (Bredth First Search) bruker Queue-datastruktur for å finne den korteste veien. | DFS (Depth First Search) bruker stakkdatastruktur. |
Definisjon | BFS er en traversal tilnærming der vi først går gjennom alle noder på samme nivå før vi går videre til neste nivå. | DFS er også en traversering der traversen begynner ved rotnoden og fortsetter gjennom nodene så langt som mulig til vi når noden uten ubesøkte nærliggende noder. |
Konseptuell forskjell | BFS bygger treet nivå for nivå. | DFS bygger treet undertre for undertre. |
Tilnærming brukt | Det fungerer på konseptet FIFO (First In First Out). | Det fungerer på konseptet LIFO (Last In First Out). |
Egnet for | BFS er mer egnet for å søke toppunkter nærmere den gitte kilden. | DFS er mer egnet når det er løsninger borte fra kilden. |
applikasjoner | BFS brukes i ulike applikasjoner som todelte grafer, korteste veier, etc. | DFS brukes i ulike applikasjoner som asykliske grafer og å finne sterkt tilkoblede komponenter etc. |
Se også BFS vs DFS for binært tre for forskjellene for en binær tregjennomgang.