# Breadth First Search without using Queue

• Difficulty Level : Medium
• Last Updated : 05 May, 2022

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;``}`

## Python3

 `# C++ implementation to demonstrate``# the above mentioned approach``from` `queue ``import` `Queue` `# Function to find the distance``# from the source to other nodes``def` `BFS(curr, N, vis,          dp,  v, adj):` `    ``while` `(curr <``=` `N) :` `        ``# Current node``        ``node ``=` `v[curr ``-` `1``]``        ``print``(node,end``=`  `", "``)` `        ``for` `i ``in` `range``(``len``(adj[node])) :` `            ``# Adjacent node``            ``next` `=` `adj[node][i]` `            ``if` `((``not` `vis[``next``]) ``and` `(dp[``next``] < dp[node] ``+` `1``)) :` `                ``# Stores the adjacent node``                ``v.append(``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``def` `bfsTraversal(adj,    N, source):``    ``# Initially mark all nodes as false``    ``vis``=``[``False``]``*``(N ``+` `1``)` `    ``# Initialize distance array with 0``    ``dp``=``[``0``]``*``(N ``+` `1``); v``=``[]` `    ``v.append(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``if` `__name__ ``=``=` `'__main__'``:``    ``# No. of nodes in graph``    ``N ``=` `4` `    ``# Creating adjacency list``    ``# for representing graph``    ``adj``=``[[] ``for` `_ ``in` `range``(N``+``1``)]``    ``adj[``0``].append(``1``)``    ``adj[``0``].append(``2``)``    ``adj[``1``].append(``2``)``    ``adj[``2``].append(``0``)``    ``adj[``2``].append(``3``)``    ``adj[``3``].append(``3``)` `    ``# Following is BFS Traversal``    ``# starting from vertex 2``    ``bfsTraversal(adj, N, ``2``)`

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