Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Hard
  • Last Updated : 26 Nov, 2020

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:  

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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
Output: 
3 4 5 6 7

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!