# Breadth First Search without using Queue

Last Updated : 08 Feb, 2023

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[0].push_back(1);` `    ``adj[0].push_back(2);` `    ``adj[1].push_back(2);` `    ``adj[2].push_back(0);` `    ``adj[2].push_back(3);` `    ``adj[3].push_back(3);`   `    ``// Following is BFS Traversal` `    ``// starting from vertex 2` `    ``bfsTraversal(adj, N, 2);`   `    ``return` `0;` `}`

## Java

 `// Java implementation to demonstrate` `// the above mentioned approach`   `import` `java.util.*;`   `public` `class` `Main {` `    ``static` `void` `bfsTraversal(List> adj, ``int` `N, ``int` `source) {` `        ``// Initially mark all nodes as false` `        ``boolean``[] vis = ``new` `boolean``[N + ``1``];` `        ``Arrays.fill(vis, ``false``);`   `        ``// Initialize distance array with 0` `        ``int``[] dp = ``new` `int``[N + ``1``];` `        ``Arrays.fill(dp, ``0``);` `        ``List v = ``new` `ArrayList<>();`   `        ``v.add(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);` `    ``}`   `    ``static` `void` `bfs(``int` `curr, ``int` `N, ``boolean``[] vis, ``int``[] dp, List v, List> adj) {` `        ``while` `(curr <= N) {` `            ``// Current node` `            ``int` `node = v.get(curr - ``1``);` `            ``System.out.print(node + ``", "``);`   `            ``for` `(``int` `i = ``0``; i < adj.get(node).size(); i++) {` `                ``// Adjacent node` `                ``int` `next = adj.get(node).get(i);`   `                ``if` `((!vis[next]) && (dp[next] < dp[node] + ``1``)) {` `                    ``// Stores the adjacent node` `                    ``v.add(next);`   `                    ``// Increases the distance` `                    ``dp[next] = dp[node] + ``1``;`   `                    ``// Mark it as visited` `                    ``vis[next] = ``true``;` `                ``}` `            ``}` `            ``curr += ``1``;` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``// No. of nodes in graph` `        ``int` `N = ``4``;`   `        ``// Creating adjacency list` `        ``// for representing graph` `        ``List> adj = ``new` `ArrayList<>();` `        ``for` `(``int` `i = ``0``; i < N + ``1``; i++) {` `            ``adj.add(``new` `ArrayList<>());` `        ``}` `        ``adj.get(``0``).add(``1``);` `        ``adj.get(``0``).add(``2``);` `        ``adj.get(``1``).add(``2``);` `        ``adj.get(``2``).add(``0``);` `        ``adj.get(``2``).add(``3``);` `        ``adj.get(``3``).add(``3``);`   `        ``// Following is BFS Traversal` `        ``// starting from vertex 2` `        ``bfsTraversal(adj, N, ``2``);` `    ``}` `}` `//This code is contributed by Potta Lokesh`

## 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``)`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `class` `Program` `{` `    ``// Function to find the distance` `    ``// from the source to other nodes` `    ``static` `void` `BFS(``int` `curr, ``int` `N, ``bool``[] vis,` `                   ``int``[] dp, List<``int``> v,` `                   ``List> adj)` `    ``{` `        ``while` `(curr <= N)` `        ``{` `            ``// Current node` `            ``int` `node = v[curr - 1];` `            ``Console.Write(node + ``", "``);`   `            ``for` `(``int` `i = 0; i < adj[node].Count; i++)` `            ``{` `                ``// Adjacent node` `                ``int` `next = adj[node][i];`   `                ``if` `((!vis[next])` `                    ``&& (dp[next] < dp[node] + 1))` `                ``{` `                    ``// Stores the adjacent node` `                    ``v.Add(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` `    ``static` `void` `BFS(List> adj, ``int` `N, ``int` `source)` `    ``{` `        ``// Initially mark all nodes as false` `        ``bool``[] vis = ``new` `bool``[N + 1];`   `        ``// Initialize distance array with 0` `        ``int``[] dp = ``new` `int``[N + 1];` `        ``List<``int``> v = ``new` `List<``int``>();`   `        ``v.Add(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` `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``// No. of nodes in graph` `        ``int` `N = 4;`   `        ``// Creating adjacency list` `        ``// for representing graph` `        ``List> adj = ``new` `List>();` `        ``for` `(``int` `i = 0; i < N + 1; i++)` `        ``{` `            ``adj.Add(``new` `List<``int``>());` `        ``}` `        ``adj[0].Add(1);` `        ``adj[0].Add(2);` `        ``adj[1].Add(2);` `        ``adj[2].Add(0);` `        ``adj[2].Add(3);` `        ``adj[3].Add(3);`   `        ``// Following is BFS Traversal` `        ``// starting from vertex 2` `        ``BFS(adj, N, 2);`   `        ``Console.ReadKey();` `    ``}` `}`

## Javascript

 `// JavaScript implementation to demonstrate` `// the above mentioned approach`   `// Function to find the distance` `// from the source to other nodes` `function` `BFS(curr, N, vis, dp, v, adj) {` `    ``while` `(curr <= N) {` `        ``// Current node` `        ``let node = v[curr - 1];` `        ``console.log(node + ``", "``);`   `        ``for` `(let i = 0; i < adj[node].length; i++) {` `            ``// Adjacent node` `            ``let next = adj[node][i];`   `            ``if` `(!vis[next] && (dp[next] < dp[node] + 1)) {` `                ``// Stores the adjacent node` `                ``v.push(next);`   `                ``// Increases the distance` `                ``dp[next] = dp[node] + 1;`   `                ``// Mark it as visited` `                ``vis[next] = ``true``;` `            ``}` `        ``}` `        ``curr++;` `    ``}` `}`   `// Function to print the distance` `// from source to other nodes` `function` `bfsTraversal(adj, N, source) {` `    ``// Initially mark all nodes as false` `    ``let vis = ``new` `Array(N + 1).fill(``false``);`   `    ``// Initialize distance array with 0` `    ``let dp = ``new` `Array(N + 1).fill(0);` `    ``let v = [];`   `    ``v.push(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` `    `  `    ``// No. of nodes in graph` `    ``let N = 4;`   `    ``// Creating adjacency list` `    ``// for representing graph` `    ``let adj = ``new` `Array(N + 1);` `    ``adj[0] = [1, 2];` `    ``adj[1] = [2];` `    ``adj[2] = [0, 3];` `    ``adj[3] = [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)

Previous Article
Next Article
Article Tags :
Practice Tags :