Refactor Bidirectional BFS implementation

Updated the Bidirectional BFS implementation to improve code clarity and structure.

Author: darkatwi

src/main/java/com/thealgorithms/datastructures/graphs/BidirectionalBFS.java

@@ -1,23 +1,33 @@
-/*
-BidirectionalBFS.java
- 
-This class implements the Bidirectional Breadth-First Search (BFS) algorithm to efficiently
-determine whether a path exists between two nodes in an unweighted graph. Instead of
-searching from the start node alone, it simultaneously explores the graph from both the
-start and goal nodes, meeting in the middle. This approach often reduces the number of
-nodes visited compared to traditional BFS, making it faster for large graphs. The main
-method provides an example graph and demonstrates usage by printing whether a path
-exists between the specified start and goal nodes.
- */
-
-
-
-import java.util.*;
+import java.util.Map;
+import java.util.List;
+import java.util.Set;
+import java.util.Queue;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.ArrayList;
+import java.util.Arrays;
 
-public class BidirectionalBFS {
-
-    public static boolean bidirectionalBFS(Map<Integer, List<Integer>> graph, int start, int goal) {
-        if (start == goal) return true;
+/**
+ * Implementation of Bidirectional Breadth-First Search (BFS) algorithm.
+ * Checks if a path exists between a start node and a goal node in an undirected graph.
+ */
+public class BidirectionalBFS
+{
+    /**
+     * Checks if a path exists between start and goal using bidirectional BFS.
+     *
+     * @param graph The adjacency list of the graph
+     * @param start The starting node
+     * @param goal  The goal node
+     * @return true if a path exists, false otherwise
+     */
+    public static boolean bidirectionalBFS(Map<Integer, List<Integer>> graph, int start, int goal)
+    {
+        if (start == goal)
+        {
+            return true;
+        }
 
         Set<Integer> visitedStart = new HashSet<>();
         Set<Integer> visitedGoal = new HashSet<>();
@@ -31,45 +41,52 @@ public static boolean bidirectionalBFS(Map<Integer, List<Integer>> graph, int st
         visitedStart.add(start);
         visitedGoal.add(goal);
 
-        while (!queueStart.isEmpty() && !queueGoal.isEmpty()) {
+        while (!queueStart.isEmpty() && !queueGoal.isEmpty())
+        {
             // Expand from start side
-            if (expandFrontier(graph, queueStart, visitedStart, visitedGoal)) return true;
+            if (expandFrontier(graph, queueStart, visitedStart, visitedGoal))
+            {
+                return true;
+            }
             // Expand from goal side
-            if (expandFrontier(graph, queueGoal, visitedGoal, visitedStart)) return true;
+            if (expandFrontier(graph, queueGoal, visitedGoal, visitedStart))
+            {
+                return true;
+            }
         }
 
-        return false; // no path found
+        return false; // No path found
     }
 
+    /**
+     * Helper function to expand one level of BFS frontier.
+     *
+     * @param graph           The adjacency list of the graph
+     * @param queue           The BFS queue for this side
+     * @param visitedThisSide Set of nodes visited from this side
+     * @param visitedOtherSide Set of nodes visited from the other side
+     * @return true if the frontiers meet, false otherwise
+     */
     private static boolean expandFrontier(Map<Integer, List<Integer>> graph, Queue<Integer> queue,
-                                          Set<Integer> visitedThisSide, Set<Integer> visitedOtherSide) {
+                                          Set<Integer> visitedThisSide, Set<Integer> visitedOtherSide)
+    {
         int size = queue.size();
-        for (int i = 0; i < size; i++) {
+        for (int i = 0; i < size; i++)
+        {
             int current = queue.poll();
-            for (int neighbor : graph.getOrDefault(current, new ArrayList<>())) {
-                if (visitedOtherSide.contains(neighbor)) return true;
-                if (!visitedThisSide.contains(neighbor)) {
+            for (int neighbor : graph.getOrDefault(current, new ArrayList<>()))
+            {
+                if (visitedOtherSide.contains(neighbor))
+                {
+                    return true;
+                }
+                if (!visitedThisSide.contains(neighbor))
+                {
                     visitedThisSide.add(neighbor);
                     queue.add(neighbor);
                 }
             }
         }
         return false;
     }
-
-    public static void main(String[] args) {
-        Map<Integer, List<Integer>> graph = new HashMap<>();
-        graph.put(0, Arrays.asList(1, 2));
-        graph.put(1, Arrays.asList(0, 3));
-        graph.put(2, Arrays.asList(0, 3, 4));
-        graph.put(3, Arrays.asList(1, 2, 5));
-        graph.put(4, Arrays.asList(2, 5));
-        graph.put(5, Arrays.asList(3, 4));
-
-        int start = 0;
-        int goal = 5;
-
-        boolean pathExists = bidirectionalBFS(graph, start, goal);
-        System.out.println("Path from " + start + " to " + goal + ": " + pathExists);
-    }
 }