Related Articles

# Breadth First Search without using Queue

• Difficulty Level : Medium
• Last Updated : 09 Aug, 2021

Breadth-first search is a graph traversal algorithm which traverse a graph or tree level by level. In this article, BFS for a Graph is implemented using Adjacency list without using a Queue.
Examples:

Input: Output: BFS traversal = 2, 0, 3, 1
Explanation:
In the following graph, we start traversal from vertex 2. When we come to vertex 0, we look for all adjacent vertices of it. 2 is also an adjacent vertex of 0. If we don’t mark visited vertices, then 2 will be processed again and it will become a non-terminating process. Therefore, a Breadth-First Traversal of the following graph is 2, 0, 3, 1.

Approach: This problem can be solved using simple breadth-first traversal from a given source. The implementation uses adjacency list representation of graphs
Here:

• STL Vector container is used to store lists of adjacent nodes and queue of nodes needed for BFS traversal.

• A DP array is used to store the distance of the nodes from the source. Every time we move from a node to another node, the distance increases by 1. If the distance to reach the nodes becomes smaller than the previous distance, we update the value stored in the DP[node].

Below is the implementation of the above approach:

## CPP

 `// C++ implementation to demonstrate``// the above mentioned approach` `#include ``using` `namespace` `std;` `// Function to find the distance``// from the source to other nodes``void` `BFS(``int` `curr, ``int` `N, vector<``bool``>& vis,``         ``vector<``int``>& dp, vector<``int``>& v,``         ``vector >& adj)``{` `    ``while` `(curr <= N) {` `        ``// Current node``        ``int` `node = v[curr - 1];``        ``cout << node << ``", "``;` `        ``for` `(``int` `i = 0; i < adj[node].size(); i++) {` `            ``// Adjacent node``            ``int` `next = adj[node][i];` `            ``if` `((!vis[next])``                ``&& (dp[next] < dp[node] + 1)) {` `                ``// Stores the adjacent node``                ``v.push_back(next);` `                ``// Increases the distance``                ``dp[next] = dp[node] + 1;` `                ``// Mark it as visited``                ``vis[next] = ``true``;``            ``}``        ``}``        ``curr += 1;``    ``}``}` `// Function to print the distance``// from source to other nodes``void` `bfsTraversal(``    ``vector >& adj,``    ``int` `N, ``int` `source)``{``    ``// Initially mark all nodes as false``    ``vector<``bool``> vis(N + 1, ``false``);` `    ``// Initialize distance array with 0``    ``vector<``int``> dp(N + 1, 0), v;` `    ``v.push_back(source);` `    ``// Initially mark the starting``    ``// source as 0 and visited as true``    ``dp = 0;``    ``vis = ``true``;` `    ``// Call the BFS function``    ``BFS(1, N, vis, dp, v, adj);``}` `// Driver code``int` `main()``{``    ``// No. of nodes in graph``    ``int` `N = 4;` `    ``// Creating adjacency list``    ``// for representing graph``    ``vector > adj(N + 1);``    ``adj.push_back(1);``    ``adj.push_back(2);``    ``adj.push_back(2);``    ``adj.push_back(0);``    ``adj.push_back(3);``    ``adj.push_back(3);` `    ``// Following is BFS Traversal``    ``// starting from vertex 2``    ``bfsTraversal(adj, N, 2);` `    ``return` `0;``}`
Output:
`2, 0, 3, 1,`

Time Complexity: O(V + E), where V is the number of vertices and E is the number of edges.
Auxiliary Space: O(V)

My Personal Notes arrow_drop_up