# Program to Print all the Non-Reachable Nodes | Using BFS

Non−reachable nodes are nodes in a chart that cannot be reached from a particular source hub. They are hubs that don't have any way of interfacing with the source hub inside the given chart. The recognisable proof of non−reachable hubs makes a difference in determining the detached or disconnected substances inside the chart. Calculations like breadth−first look (BFS) or depth−first look (DFS) can be utilised to navigate the chart and effectively stamp the gone−by hubs, subsequently encouraging the distinguishing proof of non−reachable hubs. Analysing and understanding non−reachable hubs is important in evaluating organised networks, recognising crevices in data or networks, and making educated choices for organised optimisation and advancement.

The programme utilises (BFS) calculation to distinguish and print all non−reachable hubs in a given chart. It makes a difference in assessing organisational structures, identifying data crevices, and making educated choices. The BFS calculation productively navigates the chart to discover detached or inaccessible hubs.

• BSF

## BSF

BFS stands for Breadth−First Look. It could be a chart traversal calculation that investigates all the vertices of a chart in breadth−first order, i.e., it visits all the vertices at the same level some time recently before moving to another level. The BFS calculation begins at a given source vertex and investigates its adjoining vertices. At that point, it moves to another level of vertices, going to their adjoining vertices, and so on. It employs a line information structure to keep track of the vertices to be passed by.

### Algorithm

• Initialise a line and a gone−by array:

• A line could be an information structure that follows the First−In−First−Out (FIFO) guideline. It'll be used to store the vertices during BFS traversal.

The gone−to cluster is utilised to keep track of the vertices that have been gone by or explored.

Enqueue the source vertex and check it as visited:

• The source vertex is the beginning point of the BFS traversal.

Enqueueing implies including the source vertex in the queue.

Marking the source vertex as gone guarantees that it won't be prepared again.

Perform BFS traversal:

• Repeat the following steps until the line gets empty:

• Dequeue a vertex from the queue:

Dequeuing implies evacuating a vertex from the front of the queue.

The dequeued vertex will be handled, and its adjoining vertices will be enqueued.

• Enqueue all unvisited neighbouring vertices:

For each adjoining vertex of the dequeued vertex, on the off chance that it hasn't been gone by, however, enqueue it.

This step guarantees that all reachable vertices are investigated in a breadth−first manner.

• Mark each queued vertex as visited:

After enqueuing each vertex, stamp it as gone to avoid returning to it.

• Print the non−visited vertices.

• After completing the BFS traversal, the target cluster stamps all vertices reachable from the source vertex.

Non−visited vertices speak to hubs that are not reachable from the source vertex.

Print these non−visited vertices to recognise the disconnected or non−reachable hubs within the graph.

The programme execution is total, and the yield has been generated. Exit the programme smoothly.

### Example 1

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

// Function to add an edge to graph
{
// Add w to v's list.

// Add v to w's list.
}

// BFS traversal of the vertices
// reachable from starting node
void findNonReachableNodes(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();

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

// Driver code
int main()
{
// Create a graph given in
// the above diagram
const int numVertices = 8;

return 0;
}


### Output

1 2 3 4 5 6 7


### Example 2

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

}

void findNonReachableNodes(vector<vector<int>>& adjList, int source, int numVertices) {
vector<bool> visited(numVertices, false);

queue<int> q;
q.push(source);
visited[source] = true;

while (!q.empty()) {
int vertex = q.front();
q.pop();

for (auto neighbor : adjList[vertex]) {
if (!visited[neighbor]) {
visited[neighbor] = true;
q.push(neighbor);
}
}
}

for (int i = 0; i < numVertices; i++) {
if (!visited[i]) {
cout << i << " ";
}
}
cout << endl;
}

int main() {
const int totalVertices = 8;

int sourceVertex = 0;

return 0;
}


### Output

3 4 5 6 7

## Conclusion

This article clarifies the concept of finding non−reachable hubs in a chart using the Breadth−first−look (BFS) calculation. It talks about the importance of recognising non−reachable hubs in analysing organised systems, recognising holes in information or systems, and making educated choices for arrangement optimisation and advancement. The BFS calculation is portrayed step−by−step, highlighting the initialization, traversal preparation, and printing of non−reachable hubs. A programme is given as an example to illustrate the execution of BFS for finding non−reachable hubs in a chart. The article points to a clear understanding of BFS and its application in distinguishing non−reachable hubs.

Updated on: 14-Jul-2023

39 Views