logo

Différence entre BFS et DFS

Recherche en largeur d'abord (BFS) et Recherche en profondeur d'abord (DFS) sont deux algorithmes fondamentaux utilisés pour parcourir ou rechercher des graphiques et des arbres. Cet article couvre la différence fondamentale entre la recherche en largeur d'abord et la recherche en profondeur.

alphabet sous forme de chiffres
bfs-vs-dfs-(1)

Différence entre BFS et DFS



Recherche en largeur d'abord (BFS) :

BFS, recherche en largeur d'abord, est une technique basée sur les sommets pour trouver le chemin le plus court dans le graphique. Il utilise un Sortir:

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

Code:

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; public : Graphique (int V ); // Constructeur // fonction pour ajouter une arête au graphique void addEdge(int v, int w);  // imprime le parcours BFS à partir d'une source donnée s void BFS(int s); } ; Graphique :: Graphique (int V) { this->V = V;  adj = nouvelle liste [V] ; } void Graph::addEdge(int v, int w) { adj[v].push_back(w); // Ajoute w à la liste de v. } void Graph::BFS(int s) { // Marque tous les sommets comme non visités bool* visited = new bool[V];  pour (int je = 0; je< V; i++)  visited[i] = false;  // Create a queue for BFS  list file d'attente;  // Marque le nœud actuel comme visité et le met en file d'attente visité[s] = true;  queue.push_back(s);  // 'i' sera utilisé pour obtenir tous les sommets adjacents d'une // liste de sommets ::itérateur i;  // Crée un mappage d'entiers en caractères char map[6] = { 'A', 'B', 'C', 'D', 'E', 'F ' } ;  while (!queue.empty()) { // Supprimer un sommet de la file d'attente et l'imprimer 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(() =>[]); // Tableau de listes de contiguïté } // Fonction pour ajouter une arête au graphique addEdge(v, w) { this.adj[v].push(w); // Ajoute w à la liste de v.  } // Fonction pour effectuer un parcours BFS à partir d'une source donnée s BFS(s) { // Marquer tous les sommets comme non visités let visited = new Array(this.V).fill(false);  // Crée une file d'attente pour BFS let queue = [];  // Marque le nœud actuel comme visité et le met en file d'attente visité[s] = true;  queue.push(s);  // Mappage d'entiers en caractères let map = ['A', 'B', 'C', 'D', 'E', 'F'];  while (queue.length> 0) { // Supprime un sommet de la file d'attente et l'imprime s = queue.shift();  console.log(map[s] + ' '); // Utilisez le mappage pour imprimer l'étiquette d'origine // Récupérez tous les sommets adjacents du sommet retiré de la file d'attente s // Si un adjacent n'a pas été visité, marquez-le comme visité // et mettez-le en file d'attente pour (laissez i de this.adj[s ]) { if (!visited[i]) { queue.push(i);  visité[i] = vrai;  } } } } } // Fonction principale function main() { // Crée un graphique donné dans le diagramme /* 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 largeur du premier parcours est : ');  g.BFS(0); // Démarrez BFS à partir de A (0) } // Exécutez la fonction principale main();>

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

Recherche en profondeur d'abord (DFS) :

DSF, Recherche en profondeur d'abord , est une technique basée sur les bords. Il utilise le Sortir:



statut git -s
A, B, C, D, E, F>

Différence entre BFS et DFS :

ParamètresBFSDFS
ReprésenteBFS signifie Breadth First Search.DFS signifie Recherche en profondeur d'abord.
Structure de donnéesBFS (Breadth First Search) utilise la structure de données de file d'attente pour trouver le chemin le plus court.DFS (Depth First Search) utilise la structure de données Stack.
DéfinitionBFS est une approche traversante dans laquelle nous parcourons d'abord tous les nœuds du même niveau avant de passer au niveau suivant.DFS est également une approche de traversée dans laquelle la traversée commence au nœud racine et traverse les nœuds aussi loin que possible jusqu'à ce que nous atteignions le nœud sans nœuds proches non visités.
Différence conceptuelleBFS construit l'arborescence niveau par niveau.DFS construit l'arborescence sous-arborescence par sous-arborescence.
Approche utiliséeIl fonctionne sur le concept du FIFO (First In First Out).Il fonctionne sur le concept de LIFO (Last In First Out).
Convient àBFS est plus adapté à la recherche de sommets plus proches de la source donnée.DFS est plus adapté lorsqu'il existe des solutions éloignées de la source.
ApplicationsBFS est utilisé dans diverses applications telles que les graphes bipartis, les chemins les plus courts, etc.DFS est utilisé dans diverses applications telles que les graphiques acycliques et la recherche de composants fortement connectés, etc.

Veuillez également consulter BFS vs DFS pour l'arbre binaire pour les différences pour une traversée d’arbre binaire.