Program to print all the non-reachable nodes | Using BFS

Given an undirected graph and a set of vertices, we have to print all the non-reachable nodes from the given head node using a breadth-first search.

For example:

Consider below undirected graph with two disconnected components: 

In this graph, if we consider 0 as a head node, then the node 0, 1 and 2 are reachable. We mark all the reachable nodes as visited. All those nodes which are not marked as visited i.e, node 3 and 4 are non-reachable nodes. 

Examples:

Input: 5
       0 1
       0 2
       1 2
       3 4
Output: 3 4

Input: 8
       0 1
       0 2
       1 2
       3 4
       4 5
       6 7
Output: 3 4 5 6 7

Approach:

• We can either use BFS or DFS for this purpose. Set 1 of this article implements the DFS approach. In this article, BFS approach is used.
• We do BFS from a given source. Since the given graph is undirected, all the vertices that belong to the disconnected component are non-reachable nodes. We use the visited array for this purpose, the array which is used to keep track of non-visited vertices in BFS. 
• BFS is a traversing algorithm which starts traversing from a selected node (source or starting node) and traverses the graph layer-wise thus exploring the neighbour nodes (nodes which are directly connected to source node). Then, move towards the next-level neighbour nodes. 
  

Below is the implementation of the above approach:  

C++

// C++ program to count non-reachable nodes
// from a given source using BFS.

#include <bits/stdc++.h>
using namespace std;

// Function to add an edge to graph
void add_edge(vector<int> adj[],
              int v, int w)
{
    // Add w to v’s list.
    adj[v].push_back(w);

    // Add v to w's list.
    adj[w].push_back(v);
}

// BFS traversal of the vertices
// reachable from starting node
void BFS(vector<int> adj[], int s,
         int v)
{
    // Mark all the vertices
    // as not visited
    bool visited[v] = { false };

    // Create a queue for BFS
    queue<int> q;

    // Mark the current node as
    // visited and enqueue it
    q.push(s);
    visited[s] = true;

    while (!q.empty()) {
        // Dequeue a vertex from
        // queue
        int p = q.front();
        q.pop();

        // Get all adjacent vertices
        // of the dequeued vertex p.
        // If a adjacent has not been
        // visited, then mark it
        // visited and enqueue it
        for (auto it = adj[p].begin();
             it != adj[p].end(); it++) {
            if (!visited[*it]) {
                visited[*it] = true;
                q.push(*it);
            }
        }
    }
    for (int i = 0; i < v; i++) {
        if (!visited[i]) {
            cout << i << " ";
        }
    }
    cout << "\n";
}

// Drivers code
int main()
{
    // Create a graph given in
    // the above diagram
    vector<int> adj[8];
    add_edge(adj, 0, 1);
    add_edge(adj, 0, 2);
    add_edge(adj, 1, 2);
    add_edge(adj, 3, 4);
    add_edge(adj, 4, 5);
    add_edge(adj, 6, 7);

    BFS(adj, 0, 8);

    return 0;
}

Java

// Java program to count non-reachable nodes
// from a given source using BFS.
import java.util.*;

class GFG{

// Function to add an edge to graph
static void add_edge(Vector<Integer> adj[],
              int v, int w)
{
    // Add w to v’s list.
    adj[v].add(w);

    // Add v to w's list.
    adj[w].add(v);
}

// BFS traversal of the vertices
// reachable from starting node
static void BFS(Vector<Integer> adj[], int s,
         int v)
{
    // Mark all the vertices
    // as not visited
    boolean []visited = new boolean[v];

    // Create a queue for BFS
    Queue<Integer> q = new LinkedList<>();

    // Mark the current node as
    // visited and enqueue it
    q.add(s);
    visited[s] = true;

    while (!q.isEmpty()) {

        // Dequeue a vertex from
        // queue
        int p = q.peek();
        q.remove();

        // Get all adjacent vertices
        // of the dequeued vertex p.
        // If a adjacent has not been
        // visited, then mark it
        // visited and enqueue it
        for (int it : adj[p]) {
            if (!visited[it]) {
                visited[it] = true;
                q.add(it);
            }
        }
    }
    for (int i = 0; i < v; i++) {
        if (!visited[i]) {
            System.out.print(i+ " ");
        }
    }
    System.out.print("\n");
}

// Drivers code
public static void main(String[] args)
{
    // Create a graph given in
    // the above diagram
    Vector<Integer> []adj = new Vector[8];
    for (int i = 0; i < 8; i++)
        adj[i] = new Vector<Integer>();
    add_edge(adj, 0, 1);
    add_edge(adj, 0, 2);
    add_edge(adj, 1, 2);
    add_edge(adj, 3, 4);
    add_edge(adj, 4, 5);
    add_edge(adj, 6, 7);

    BFS(adj, 0, 8);

}
}

// This code is contributed by sapnasingh4991

Python3

# Python3 program to count non-reachable
# nodes from a given source using BFS

# Function to add an edge to graph
def add_edge(adj, v, w):

    # Add w to v’s list
    adj[v].append(w)

    # Add v to w's list
    adj[w].append(v)

# BFS traversal of the vertices
# reachable from starting node
def BFS(adj, s, v):

    # Mark all the vertices
    # as not visited
    visited = [False for i in range(v)]

    # Create a queue for BFS
    q = []

    # Mark the current node as
    # visited and enqueue it
    q.append(s)
    visited[s] = True

    while (len(q) != 0):

        # Dequeue a vertex from
        # queue
        p = q[0]
        q.pop(0)

        # Get all adjacent vertices
        # of the dequeued vertex p.
        # If a adjacent has not been
        # visited, then mark it
        # visited and enqueue it
        for it in adj[p]:
            if (not visited[it]):
                visited[it] = True
                q.append(it)

    for i in range(v):
        if (not visited[i]):
            print(i, end = ' ')

    print()

# Driver code
if __name__=='__main__':

    # Create a graph given in
    # the above diagram
    adj = [[] for i in range(8)]

    add_edge(adj, 0, 1)
    add_edge(adj, 0, 2)
    add_edge(adj, 1, 2)
    add_edge(adj, 3, 4)
    add_edge(adj, 4, 5)
    add_edge(adj, 6, 7)

    BFS(adj, 0, 8)

# This code is contributed by rutvik_56

C#

// C# program to count non-reachable nodes
// from a given source using BFS.
using System;
using System.Collections.Generic;

class GFG{

// Function to add an edge to graph
static void add_edge(List<int> []adj,
              int v, int w)
{
    // Add w to v’s list.
    adj[v].Add(w);

    // Add v to w's list.
    adj[w].Add(v);
}

// BFS traversal of the vertices
// reachable from starting node
static void BFS(List<int> []adj, int s,
         int v)
{
    // Mark all the vertices
    // as not visited
    bool []visited = new bool[v];

    // Create a queue for BFS
    List<int> q = new List<int>();

    // Mark the current node as
    // visited and enqueue it
    q.Add(s);
    visited[s] = true;

    while (q.Count != 0) {

        // Dequeue a vertex from
        // queue
        int p = q[0];
        q.RemoveAt(0);

        // Get all adjacent vertices
        // of the dequeued vertex p.
        // If a adjacent has not been
        // visited, then mark it
        // visited and enqueue it
        foreach (int it in adj[p]) {
            if (!visited[it]) {
                visited[it] = true;
                q.Add(it);
            }
        }
    }
    for (int i = 0; i < v; i++) {
        if (!visited[i]) {
            Console.Write(i + " ");
        }
    }
    Console.Write("\n");
}

// Driver's code
public static void Main(String[] args)
{
    // Create a graph given in
    // the above diagram
    List<int> []adj = new List<int>[8];
    for (int i = 0; i < 8; i++)
        adj[i] = new List<int>();
    add_edge(adj, 0, 1);
    add_edge(adj, 0, 2);
    add_edge(adj, 1, 2);
    add_edge(adj, 3, 4);
    add_edge(adj, 4, 5);
    add_edge(adj, 6, 7);

    BFS(adj, 0, 8);
}
}

// This code is contributed by 29AjayKumar

Javascript

<script>

// JavaScript program to count non-reachable
// nodes from a given source using BFS

// Function to add an edge to graph
function add_edge(adj, v, w){

    // Add w to v’s list
    adj[v].push(w)

    // Add v to w's list
    adj[w].push(v)
}

// BFS traversal of the vertices
// reachable from starting node
function BFS(adj, s, v){

    // Mark all the vertices
    // as not visited
    let visited = new Array(v).fill(false)

    // Create a queue for BFS
    let q = []

    // Mark the current node as
    // visited and enqueue it
    q.push(s)
    visited[s] = true

    while (q.length != 0){

        // Dequeue a vertex from
        // queue
        let p = q.shift()

        // Get all adjacent vertices
        // of the dequeued vertex p.
        // If a adjacent has not been
        // visited, then mark it
        // visited and enqueue it
        for(let it of adj[p]){
            if (!visited[it]){
                visited[it] = true
                q.push(it)
            }
        }
    }

    for(let i=0;i<v;i++){
        if (!visited[i]){
            document.write(i,' ')
        }
    }

    document.write("</br>")
}

// Driver code

// Create a graph given in
// the above diagram
let adj = new Array(8)
for(let i=0;i<8;i++){
    adj[i] = new Array()
}

add_edge(adj, 0, 1)
add_edge(adj, 0, 2)
add_edge(adj, 1, 2)
add_edge(adj, 3, 4)
add_edge(adj, 4, 5)
add_edge(adj, 6, 7)

BFS(adj, 0, 8)

// This code is contributed by Shinjanpatra

</script>

Output:

3 4 5 6 7