What Is BFS and DFS in Data Structure?


Scott Campbell

Understanding the concepts of Breadth First Search (BFS) and Depth First Search (DFS) is crucial in the field of data structures. These algorithms are widely used for traversing or searching graph-based data structures. Let’s dive into the details of BFS and DFS and explore their differences, use cases, and implementation.

Breadth First Search (BFS)

BFS is a graph traversal algorithm that explores all the vertices of a graph in breadth-first order. It starts at a given vertex and visits all its neighbors before moving on to the next level of vertices. In other words, it explores all the vertices at the same level before moving deeper into the graph.


To implement BFS, we typically use a queue data structure. We enqueue the starting vertex and mark it as visited.

Then, while there are vertices in the queue, we dequeue a vertex, visit it, enqueue its unvisited neighbors, and mark them as visited. This process continues until the queue is empty.

Use Cases

  • BFS is commonly used to find the shortest path between two nodes in an unweighted graph.
  • It can be employed to solve various graph-related problems where exploring neighbors at each level is necessary.

Depth First Search (DFS)

DFS is another popular algorithm for traversing or searching graphs. Unlike BFS, DFS explores vertices depth-wise before backtracking to explore other branches.


A stack or recursion can be utilized for implementing DFS. We start at a given vertex, mark it as visited, visit it, and then recursively explore its unvisited neighbors until there are no more unvisited neighbors left.

Use Cases

  • DFS is often used to detect cycles in a graph.
  • It can be employed to solve problems that require exploring all possible paths in a graph.

Differences Between BFS and DFS

The main difference between BFS and DFS lies in the order in which they explore vertices. BFS explores vertices level-by-level, while DFS explores them depth-wise.

  • BFS: Breadth-first search follows the First-In-First-Out (FIFO) principle using a queue data structure.
  • DFS: Depth-first search follows the Last-In-First-Out (LIFO) principle using a stack or recursion.


In summary, BFS and DFS are both fundamental graph traversal algorithms used to explore or search graph-based data structures. BFS explores vertices level-by-level using a queue, while DFS explores them depth-wise using a stack or recursion. Understanding these algorithms is essential for solving various graph-related problems efficiently.

Now that you have grasped the concepts of BFS and DFS, you can start applying them to solve real-world problems involving graphs. Happy coding!

Discord Server - Web Server - Private Server - DNS Server - Object-Oriented Programming - Scripting - Data Types - Data Structures

Privacy Policy