logo

Diferencia entre BFS y DFS

Búsqueda en amplitud (BFS) y Búsqueda en profundidad (DFS) son dos algoritmos fundamentales que se utilizan para recorrer o buscar gráficos y árboles. Este artículo cubre la diferencia básica entre la búsqueda en amplitud y la búsqueda en profundidad.

colecciones java java
bfs-vs-dfs-(1)

Diferencia entre BFS y DFS



Búsqueda en amplitud (BFS) :

BFS, búsqueda en amplitud, es una técnica basada en vértices para encontrar el camino más corto en el gráfico. Utiliza un Producción:

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

Código:

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; público: Gráfico (int V); // Constructor // función para agregar un borde al gráfico void addEdge(int v, int w);  // imprime el recorrido BFS desde una fuente determinada s void BFS(int s); }; Gráfico::Gráfico(int V) { this->V = V;  adj = nueva lista [V]; } void Graph::addEdge(int v, int w) { adj[v].push_back(w); // Agrega w a la lista de v. } void Graph::BFS(int s) { // Marcar todos los vértices como no visitados bool* visitado = new bool[V];  para (int i = 0; i< V; i++)  visited[i] = false;  // Create a queue for BFS  list cola;  // Marca el nodo actual como visitado y ponlo en cola visitado[s] = true;  cola.push_back(s);  // 'i' se usará para obtener todos los vértices adyacentes de una // lista de vértices ::iterador i;  // Crea una asignación de números enteros a caracteres char map[6] = { 'A', 'B', 'C', 'D', 'E', 'F ' };  while (!queue.empty()) { // Quitar un vértice de la cola e imprimirlo s = queue.front();  corte<< 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; }>
Pitón
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(() =>[]); // Matriz de listas de adyacencia } // Función para agregar un borde al gráfico addEdge(v, w) { this.adj[v].push(w); // Agrega w a la lista de v.  } // Función para realizar un recorrido BFS desde una fuente determinada s BFS(s) { // Marcar todos los vértices como no visitados let visitado = new Array(this.V).fill(false);  // Crea una cola para BFS let queue = [];  // Marca el nodo actual como visitado y ponlo en cola visitado[s] = true;  cola.push(s);  // Mapeo de números enteros a caracteres let map = ['A', 'B', 'C', 'D', 'E', 'F'];  while (queue.length> 0) { // Quitar un vértice de la cola e imprimirlo s = queue.shift();  console.log(mapa[s] + ' '); // Usar el mapeo para imprimir la etiqueta original // Obtener todos los vértices adyacentes de los vértices s retirados de la cola // Si un adyacente no ha sido visitado, márquelo como visitado // y póngalo en cola para (sea i de this.adj[s ]) { if (!visitado[i]) { cola.push(i);  visitado[i] = verdadero;  } } } } } // Función principal function main() { // Crea un gráfico dado en el diagrama /* 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('La amplitud del primer recorrido es: ');  g.BFS(0); // Iniciar BFS desde A (0) } // Ejecutar la función principal main();>

Producción
Breadth First Traversal is: A B C D E F>

Primera búsqueda en profundidad (DFS) :

DFS, Primera búsqueda en profundidad , es una técnica basada en bordes. Utiliza el Producción:



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

Diferencia entre BFS y DFS:

ParámetrosBFSDFS
RepresentaBFS significa Búsqueda primero en amplitud.DFS significa Búsqueda en profundidad primero.
Estructura de datosBFS (Breadth First Search) utiliza la estructura de datos de cola para encontrar la ruta más corta.DFS (primera búsqueda en profundidad) utiliza la estructura de datos de pila.
DefiniciónBFS es un enfoque transversal en el que primero recorremos todos los nodos del mismo nivel antes de pasar al siguiente nivel.DFS también es un enfoque transversal en el que el recorrido comienza en el nodo raíz y continúa a través de los nodos lo más lejos posible hasta llegar al nodo sin nodos cercanos no visitados.
Diferencia conceptualBFS construye el árbol nivel por nivel.DFS construye el árbol subárbol por subárbol.
Enfoque utilizadoFunciona según el concepto de FIFO (primero en entrar, primero en salir).Funciona según el concepto de LIFO (Last In First Out).
Adecuado paraBFS es más adecuado para buscar vértices más cercanos a la fuente dada.DFS es más adecuado cuando hay soluciones fuera de la fuente.
AplicacionesBFS se utiliza en diversas aplicaciones, como gráficos bipartitos, caminos más cortos, etc.DFS se utiliza en diversas aplicaciones, como gráficos acíclicos y búsqueda de componentes fuertemente conectados, etc.

Por favor vea también BFS vs DFS para árbol binario para las diferencias para un recorrido de árbol binario.