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

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ámetros | BFS | DFS |
---|---|---|
Representa | BFS significa Búsqueda primero en amplitud. | DFS significa Búsqueda en profundidad primero. |
Estructura de datos | BFS (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ón | BFS 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 conceptual | BFS construye el árbol nivel por nivel. | DFS construye el árbol subárbol por subárbol. |
Enfoque utilizado | Funciona según el concepto de FIFO (primero en entrar, primero en salir). | Funciona según el concepto de LIFO (Last In First Out). |
Adecuado para | BFS 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. |
Aplicaciones | BFS 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.