Fix: apply google java format

Author: SiddhiPandey08

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

@@ -10,37 +10,28 @@
 /**
  * Topological Sort using Depth-First Search (DFS).
  *
- * <p>
- * A topological ordering of a directed acyclic graph (DAG) is a linear ordering
+ * <p>A topological ordering of a directed acyclic graph (DAG) is a linear ordering
  * of its vertices such that for every directed edge u → v, vertex u appears
  * before vertex v in the ordering.
  *
- * <p>
- * This implementation uses DFS with a 3-state visited array:
+ * <p>This implementation uses DFS with a 3-state visited array:
  * <ul>
- * <li>UNVISITED – node has not been visited yet</li>
- * <li>IN_PROGRESS – node is on the current DFS path (used for cycle
- * detection)</li>
- * <li>DONE – node and all its descendants are fully processed</li>
+ *   <li>UNVISITED – node has not been visited yet</li>
+ *   <li>IN_PROGRESS – node is on the current DFS path (used for cycle detection)</li>
+ *   <li>DONE – node and all its descendants are fully processed</li>
  * </ul>
  *
- * <p>
- * Time Complexity: O(V + E), where V = vertices, E = edges
+ * <p>Time Complexity: O(V + E), where V = vertices, E = edges
  * Space Complexity: O(V + E) for the adjacency list and recursion stack
  *
- * @see <a href="https://en.wikipedia.org/wiki/Topological_sorting">Topological
- *      Sorting (Wikipedia)</a>
+ * @see <a href="https://en.wikipedia.org/wiki/Topological_sorting">Topological Sorting (Wikipedia)</a>
  */
-public class TopologicalSortDFS {
+public final class TopologicalSortDFS {
 
     public TopologicalSortDFS() {
     }
 
-    private enum VisitState {
-        UNVISITED,
-        IN_PROGRESS,
-        DONE
-    }
+    private enum VisitState { UNVISITED, IN_PROGRESS, DONE }
 
     private final Map<Integer, List<Integer>> adjacencyList = new HashMap<>();
 
@@ -69,8 +60,7 @@ public void addVertex(int v) {
      * Performs a topological sort of the graph using DFS.
      *
      * @return a {@link List} of vertices in topologically sorted order
-     * @throws IllegalStateException if the graph contains a cycle (i.e., is not a
-     *                               DAG)
+     * @throws IllegalStateException if the graph contains a cycle (i.e., is not a DAG)
      */
     public List<Integer> topologicalSort() {
         Map<Integer, VisitState> visitState = new HashMap<>();
@@ -107,16 +97,13 @@ private void dfs(int vertex, Map<Integer, VisitState> visitState, Deque<Integer>
         for (int neighbor : adjacencyList.get(vertex)) {
             VisitState state = visitState.get(neighbor);
             if (state == VisitState.IN_PROGRESS) {
-                // Back edge found → cycle exists → not a DAG
-                throw new IllegalStateException(
-                        "Graph contains a cycle. Topological sort is not possible.");
+                throw new IllegalStateException("Graph contains a cycle. Topological sort is not possible.");
             }
             if (state == VisitState.UNVISITED) {
                 dfs(neighbor, visitState, stack);
             }
         }
 
-        // All descendants processed — mark done and push to stack
         visitState.put(vertex, VisitState.DONE);
         stack.push(vertex);
     }

src/test/java/com/thealgorithms/datastructures/graphs/TopologicalSortDFSTest.java

@@ -9,32 +9,19 @@
 
 /**
  * JUnit 5 tests for {@link TopologicalSortDFS}.
- *
- * Test cases cover:
- * - Standard DAG with a clear expected topological order
- * - Multiple valid orderings (validated by constraint checking)
- * - Graphs with cycles (must throw IllegalStateException)
- * - Single-node graph
- * - Disconnected graph
  */
 class TopologicalSortDFSTest {
 
-    /**
-     * Checks that every edge u → v satisfies: u appears before v in the result.
-     */
     private static void assertValidTopologicalOrder(List<Integer> order, int[][] edges) {
         for (int[] edge : edges) {
             int u = edge[0];
             int v = edge[1];
-            assertTrue(
-                    order.indexOf(u) < order.indexOf(v),
-                    "Expected " + u + " to appear before " + v + " in topological order. Got: " + order);
+            assertTrue(order.indexOf(u) < order.indexOf(v), "Expected " + u + " to appear before " + v + " in topological order. Got: " + order);
         }
     }
 
     @Test
     void testSimpleLinearGraph() {
-        // 0 → 1 → 2 → 3
         TopologicalSortDFS graph = new TopologicalSortDFS();
         graph.addEdge(0, 1);
         graph.addEdge(1, 2);
@@ -46,15 +33,9 @@ void testSimpleLinearGraph() {
 
     @Test
     void testDAGWithMultiplePaths() {
-        // Graph:
-        // 5 → 2
-        // 5 → 0
-        // 4 → 0
-        // 4 → 1
-        // 2 → 3
-        // 3 → 1
+        // 5 → 2, 5 → 0, 4 → 0, 4 → 1, 2 → 3, 3 → 1
         TopologicalSortDFS graph = new TopologicalSortDFS();
-        int[][] edges = { { 5, 2 }, { 5, 0 }, { 4, 0 }, { 4, 1 }, { 2, 3 }, { 3, 1 } };
+        int[][] edges = {{5, 2}, {5, 0}, {4, 0}, {4, 1}, {2, 3}, {3, 1}};
         for (int[] edge : edges) {
             graph.addEdge(edge[0], edge[1]);
         }
@@ -66,12 +47,9 @@ void testDAGWithMultiplePaths() {
 
     @Test
     void testBuildOrderDAG() {
-        // Simulates build dependency: A depends on nothing, B depends on A, C depends
-        // on A and B
-        // A=0, B=1, C=2, D=3
         // 0 → 1, 0 → 2, 1 → 3, 2 → 3
         TopologicalSortDFS graph = new TopologicalSortDFS();
-        int[][] edges = { { 0, 1 }, { 0, 2 }, { 1, 3 }, { 2, 3 } };
+        int[][] edges = {{0, 1}, {0, 2}, {1, 3}, {2, 3}};
         for (int[] edge : edges) {
             graph.addEdge(edge[0], edge[1]);
         }
@@ -92,9 +70,8 @@ void testSingleVertex() {
 
     @Test
     void testDisconnectedGraph() {
-        // Two disconnected components: 0 → 1 and 2 → 3
         TopologicalSortDFS graph = new TopologicalSortDFS();
-        int[][] edges = { { 0, 1 }, { 2, 3 } };
+        int[][] edges = {{0, 1}, {2, 3}};
         for (int[] edge : edges) {
             graph.addEdge(edge[0], edge[1]);
         }
@@ -106,43 +83,31 @@ void testDisconnectedGraph() {
 
     @Test
     void testSimpleCycleThrowsException() {
-        // 0 → 1 → 2 → 0 (cycle)
         TopologicalSortDFS graph = new TopologicalSortDFS();
         graph.addEdge(0, 1);
         graph.addEdge(1, 2);
         graph.addEdge(2, 0);
 
-        assertThrows(
-                IllegalStateException.class,
-                graph::topologicalSort,
-                "Expected IllegalStateException for cyclic graph");
+        assertThrows(IllegalStateException.class, graph::topologicalSort, "Expected IllegalStateException for cyclic graph");
     }
 
     @Test
     void testSelfLoopThrowsException() {
-        // A self-loop is a trivial cycle: 0 → 0
         TopologicalSortDFS graph = new TopologicalSortDFS();
         graph.addEdge(0, 0);
 
-        assertThrows(
-                IllegalStateException.class,
-                graph::topologicalSort,
-                "Expected IllegalStateException for self-loop");
+        assertThrows(IllegalStateException.class, graph::topologicalSort, "Expected IllegalStateException for self-loop");
     }
 
     @Test
     void testLargerCycleThrowsException() {
-        // 0 → 1 → 2 → 3 → 4 → 2 (cycle at 2 → 3 → 4 → 2)
         TopologicalSortDFS graph = new TopologicalSortDFS();
         graph.addEdge(0, 1);
         graph.addEdge(1, 2);
         graph.addEdge(2, 3);
         graph.addEdge(3, 4);
         graph.addEdge(4, 2);
 
-        assertThrows(
-                IllegalStateException.class,
-                graph::topologicalSort,
-                "Expected IllegalStateException for graph with cycle");
+        assertThrows(IllegalStateException.class, graph::topologicalSort, "Expected IllegalStateException for graph with cycle");
     }
 }