logo

Differenza tra BFS e DFS

Ricerca in ampiezza (BFS) E Ricerca in profondità (DFS) sono due algoritmi fondamentali utilizzati per attraversare o cercare grafi e alberi. Questo articolo illustra la differenza fondamentale tra la ricerca in ampiezza e la ricerca in profondità.

bfs-vs-dfs-(1)

Differenza tra BFS e DFS



Ricerca in ampiezza (BFS) :

BFS, ricerca in ampiezza, è una tecnica basata sui vertici per trovare il percorso più breve nel grafico. Utilizza a Produzione:

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

Codice:

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 * agg; pubblico: Graph(int V); // Costruttore // funzione per aggiungere un bordo al grafico void addEdge(int v, int w);  // stampa l'attraversamento BFS da una determinata origine s void BFS(int s); }; Grafico::Grafico(int V) { questo->V = V;  agg = nuova lista [V]; } void Graph::addEdge(int v, int w) { adj[v].push_back(w); // Aggiunge w all'elenco di v. } void Graph::BFS(int s) { // Segna tutti i vertici come non visitati bool* visitato = new bool[V];  for (int i = 0; i< V; i++)  visited[i] = false;  // Create a queue for BFS  list coda;  // Contrassegna il nodo corrente come visitato e accodalo Visited[s] = true;  coda.push_back(s);  // 'i' verrà utilizzato per ottenere tutti i vertici adiacenti di una // lista di vertici ::iteratore i;  // Crea una mappatura da numeri interi a caratteri char map[6] = { 'A', 'B', 'C', 'D', 'E', 'F '};  while (!queue.empty()) { // Rimuovi dalla coda un vertice dalla coda e stampalo 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; }>
Pitone
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 di elenchi di adiacenza } // Funzione per aggiungere un bordo al grafico addEdge(v, w) { this.adj[v].push(w); // Aggiunge w all'elenco di v.  } // Funzione per eseguire l'attraversamento BFS da una determinata sorgente s BFS(s) { // Contrassegna tutti i vertici come non visitati let visited = new Array(this.V).fill(false);  // Crea una coda per BFS let Queue = [];  // Contrassegna il nodo corrente come visitato e accodalo Visited[s] = true;  coda.push(s);  // Mappatura da numeri interi a caratteri let map = ['A', 'B', 'C', 'D', 'E', 'F'];  while (queue.length> 0) { // Rimuovi dalla coda un vertice dalla coda e stampalo s = Queue.shift();  console.log(mappa[s] + ' '); // Usa la mappatura per stampare l'etichetta originale // Ottieni tutti i vertici adiacenti del vertice rimosso dalla coda s // Se un adiacente non è stato visitato, contrassegnalo come visitato // e accodalo per (let i of this.adj[s ]) { if (!visited[i]) { coda.push(i);  visitato[i] = vero;  } } } } } // Funzione principale function main() { // Crea un grafico indicato nel diagramma /* 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('L'ampiezza del primo attraversamento è: ');  g.BFS(0); // Avvia BFS da A (0) } // Esegue la funzione principale main();>

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

Prima ricerca in profondità (DFS) :

DFS, Prima ricerca in profondità , è una tecnica basata sui bordi. Utilizza il Produzione:



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

Differenza tra BFS e DFS:

ParametriBFSDFS
Sta perBFS sta per Breadth First Search.DFS sta per Depth First Search.
Struttura datiBFS (Breadth First Search) utilizza la struttura dei dati della coda per trovare il percorso più breve.DFS (Depth First Search) utilizza la struttura dei dati Stack.
DefinizioneBFS è un approccio trasversale in cui prima attraversiamo tutti i nodi sullo stesso livello prima di passare al livello successivo.DFS è anche un approccio trasversale in cui la traversata inizia dal nodo radice e procede attraverso i nodi il più lontano possibile fino a raggiungere il nodo senza nodi vicini non visitati.
Differenza concettualeBFS costruisce l'albero livello per livello.DFS crea il sottoalbero dell'albero per sottoalbero.
Approccio utilizzatoFunziona sul concetto FIFO (First In First Out).Funziona sul concetto di LIFO (Last In First Out).
Adatto aBFS è più adatto per cercare vertici più vicini alla sorgente data.DFS è più adatto quando sono presenti soluzioni lontane dall'origine.
ApplicazioniBFS viene utilizzato in varie applicazioni come grafici bipartiti, percorsi più brevi, ecc.DFS viene utilizzato in varie applicazioni come grafici aciclici e ricerca di componenti fortemente connessi ecc.

Si prega di vedere anche BFS vs DFS per albero binario per le differenze per un attraversamento di alberi binari.