Breadth First Search without using Queue

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)

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);