Implement Breadth First Search using Java: I don't understand some of the code - search

Question

class CheckBFS {
public static String bfs(Graph g){
String result = "";
//Checking if the graph has no vertices
if (g.vertices < 1){
return result;
}
//Boolean Array to hold the history of visited nodes (by default-false)
boolean[] visited = new boolean[g.vertices];
for(int i=0;i<g.vertices;i++)
{
//Checking whether the node is visited or not
if(!visited[i])
{
result = result + bfsVisit(g, i, visited);
}
}
return result;
}
public static String bfsVisit(Graph g, int source, boolean[] visited) {
String result = "";
//Create Queue for Breadth First Traversal and enqueue source in it
Queue<Integer> queue = new Queue<>(g.vertices);
queue.enqueue(source);
visited[source] = true;
//Traverse while queue is not empty
while (!queue.isEmpty()) {
//Dequeue a vertex/node from queue and add it to result
int current_node = queue.dequeue();
result += String.valueOf(current_node);
//Get adjacent vertices to the current_node from the array,
//and if they are not already visited then enqueue them in the Queue
DoublyLinkedList<Integer>.Node temp = null;
if(g.adjacencyList[current_node] != null)
temp = g.adjacencyList[current_node].headNode;
while (temp != null) {
if (!visited[temp.data]) {
queue.enqueue(temp.data);
visited[temp.data] = true; //Visit the current Node
}
temp = temp.nextNode;
}
}//end of while
return result;
}
public static void main(String args[]) {
Graph g = new Graph(5);
g.addEdge(0,1);
g.addEdge(0,2);
g.addEdge(1,3);
g.addEdge(1,4);
System.out.println("Graph1:");
g.printGraph();
System.out.println("BFS traversal of Graph1 : " + bfs(g));
System.out.println();
Graph g2 = new Graph(5);
g2.addEdge(0,1);
g2.addEdge(0,4);
g2.addEdge(1,2);
g2.addEdge(3,4);
System.out.println("Graph2:");
g2.printGraph();
System.out.println("BFS traversal of Graph2 : " + bfs(g2));
}
}
hello,guys! I know this may sound stupid but I am very new to coding and I have no one in real life to seek help for.
My question is: could anybody explain bfsVisit method to me?
especially the code below, so we created a queue to store all the nodes/vertices that we have visited and the part below is how we "extract" nodes/ vertices from the doublyLinkedList one by one and put them into the queue?
DoublyLinkedList.Node temp = null;
if(g.adjacencyList[current_node] != null)
temp = g.adjacencyList[current_node].headNode;
while (temp != null) {
if (!visited[temp.data]) {
queue.enqueue(temp.data);
visited[temp.data] = true; //Visit the current Node
}
temp = temp.nextNode;
}
I am not sure if I get the logic of all the two methods in class CheckBFS
why should we separate the methods into bfs and bfsVisit?
So bfs is the primary method that count/store/record the nodes we visited and bfsVisit is actually the method that help us traverse the array of linkedlist?
Thanks very much!!!!

Answer 1

could anybody explain bfsVisit method to me?
bfsVisit intends to visit all nodes that can be reached from the given source node. Here are some aspects of that part of the algorithm:
visited is important, as it makes sure that the algorithm will not fall into an infinite loop when it encounters a cycle in the graph. Imagine for instance three nodes A, B, and C, where A connects to B, and B connects to C, and C connects to A. We don't want the algorithm to just keep running in circles, revisiting the same nodes over and over again. And so when A is visited the first time, it is marked as visited in the visited boolean array. When the algorithm would meet A again, it would skip it.
queue is something that is typical for breadth-first traversals: it ensures that the nodes that are closest (in terms of edges) to the source node are visited first. So first the nodes that are only one edge apart from the source node are visited, then those that are two edges apart, ...etc. To achieve this order we need a first-in-first-out data structure, which is what queue is.
especially the code below, so we created a queue to store all the nodes/vertices that we have visited and the part below is how we "extract" nodes/ vertices from the doublyLinkedList one by one and put them into the queue?
Yes. The aspect of the doubly linked list is not that important: it happens to be the data structure that the Graph class uses to give access to a node's neighboring nodes. But that is an implementation detail of Graph and is not essential for the breadth-first algorithm. What matters is that somehow you can get hold of the neighboring nodes. This could have been a vector or an array, or any collection data type that could provide you with the neighbors. It is determined by the Graph class.
temp represents that list of neighbors. I find the name of that variable not helpful. Its name could have been more descriptive, like neighbor.
That inner loop intends to loop over all direct neighbors of a given node current_node. For each of the neighbors it is first assured that it was not visited before. In that case it is marked as visited and put at the end of the queue. The queue will hold it until it becomes the first in the queue, and then it will play the role of current_node so that it expends to its own neighbors, ...etc.
temp = temp->nextNode just picks the next neighbor from the list of neighbors. As I stated before, this is an implementation detail and would have looked different if the collection of neighbors would have been provided in a different data structure. What matters is that this loop goes through the list of neighbors and deals with those that were not visited before.
why should we separate the methods into bfs and bfsVisit?
Some of the reasons:
bfsVisit can only visit nodes that are connected to the source node. If the graph happens to be a graph with disconnected components. In that case it is impossible for bfsVisit to find all nodes of the graph. That's why we have the loop in bfs: it makes sure to run bfsVisit on each component of the graph, as otherwise we would only have visited one component.
bfs actually does not perform a BFS traversal itself. I should stress here that the name bfs for the main function is thus a bit misleading: BFS is a term that only makes sense for the collection of nodes in one component. The loop we find in bfs would actually look exactly the same if the purpose was to perform a dfs traversal! That loop's purpose is only to ensure that all nodes of a graph are visited even when the graph has multiple components. Notice how bfs does not use a queue for its own purposes. It just iterates the nodes in their numerical order without any regard of edges. This is entirely different from bfsVisit which looks for connected nodes, following edges.
bfsVisit is also a kind of helper function: it receives arguments that the main function bfs did not get itself as arguments, but manages itself:
visited is the most important of those. bfs starts out by the assumption that no nodes have been visited at all. bfsVisit however needs to tell bfs which nodes it had visited once it completes.
source is the starting point for bfsVisit: it is always one of the nodes that belong to a graph component that was not visited before. This is different from bst which just chooses itself which nodes to visit without any specific node given by the caller.
I hope this clarifies it.