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à.

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:
| Parametri | BFS | DFS |
|---|---|---|
| Sta per | BFS sta per Breadth First Search. | DFS sta per Depth First Search. |
| Struttura dati | BFS (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. |
| Definizione | BFS è 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 concettuale | BFS costruisce l'albero livello per livello. | DFS crea il sottoalbero dell'albero per sottoalbero. |
| Approccio utilizzato | Funziona sul concetto FIFO (First In First Out). | Funziona sul concetto di LIFO (Last In First Out). |
| Adatto a | BFS è più adatto per cercare vertici più vicini alla sorgente data. | DFS è più adatto quando sono presenti soluzioni lontane dall'origine. |
| Applicazioni | BFS 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.