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 <bits/stdc++.h>
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<vector<int> >& 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<vector<int> >& 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<vector<int> > 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<List<Integer>> 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<Integer> 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<Integer> v, List<List<Integer>> 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<List<Integer>> 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<List<int>> 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<List<int>> 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<List<int>> adj = new List<List<int>>();
        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)

BFS using vectors & queue as per the algorithm of CLRS

heyiamsurya

Improve

Article Tags :

Practice Tags :

Breadth First Search without using Queue

CPP

Java

Python3

C#

Javascript

Similar Reads

BFS in different language

Variations of BFS implementations

Easy problems on BFS

Intermediate problems on BFS

Hard Problems on BFS