fix: Resolve PMD CollapsibleIfStatements violation and clang-format issues

Author: gowtham1412-p

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

@@ -58,7 +58,7 @@ public List<Integer> topologicalSort() {
 
         for (int i = 0; i < vertices; i++) {
             if (!visited[i]) {
-                topologicalSortDFS(i, visited, stack);
+                dfs(i, visited, stack);
             }
         }
 
@@ -71,66 +71,87 @@ public List<Integer> topologicalSort() {
     }
 
     /**
-     * DFS helper method to detect cycles
+     * Recursive DFS helper method for topological sort
      *
      * @param vertex Current vertex
      * @param visited Visited array
-     * @param recursionStack Recursion stack to detect back edges
-     * @return true if cycle is detected, false otherwise
+     * @param stack Stack to store the topological order
      */
-    private boolean hasCycleDFS(int vertex, boolean[] visited, boolean[] recursionStack) {
+    private void dfs(int vertex, boolean[] visited, Stack<Integer> stack) {
         visited[vertex] = true;
-        recursionStack[vertex] = true;
 
         for (int neighbor : adjList.get(vertex)) {
             if (!visited[neighbor]) {
-                if (hasCycleDFS(neighbor, visited, recursionStack)) {
-                    return true;
-                }
-            } else if (recursionStack[neighbor]) {
-                return true; // Back edge found - cycle detected
+                dfs(neighbor, visited, stack);
             }
         }
 
-        recursionStack[vertex] = false;
-        return false;
+        stack.push(vertex);
+    }
+
+    /**
+     * Check if the graph is a Directed Acyclic Graph (DAG)
+     *
+     * @return true if graph is DAG, false otherwise
+     */
+    private boolean isDAG() {
+        boolean[] visited = new boolean[vertices];
+        boolean[] recStack = new boolean[vertices];
+
+        for (int i = 0; i < vertices; i++) {
+            if (hasCycle(i, visited, recStack)) {
+                return false;
+            }
+        }
+
+        return true;
     }
 
     /**
-     * DFS helper method for topological sort
+     * Helper method to detect cycle in the graph
      *
      * @param vertex Current vertex
      * @param visited Visited array
-     * @param stack Stack to store topological order
+     * @param recStack Recursion stack to track vertices in current path
+     * @return true if cycle is detected, false otherwise
      */
-    private void topologicalSortDFS(int vertex, boolean[] visited, Stack<Integer> stack) {
+    private boolean hasCycle(int vertex, boolean[] visited, boolean[] recStack) {
+        if (recStack[vertex]) {
+            return true;
+        }
+
+        if (visited[vertex]) {
+            return false;
+        }
+
         visited[vertex] = true;
+        recStack[vertex] = true;
 
         for (int neighbor : adjList.get(vertex)) {
-            if (!visited[neighbor]) {
-                topologicalSortDFS(neighbor, visited, stack);
+            if (hasCycle(neighbor, visited, recStack)) {
+                return true;
             }
         }
 
-        stack.push(vertex);
+        recStack[vertex] = false;
+        return false;
     }
 
     /**
-     * Check if the graph is a DAG (Directed Acyclic Graph)
+     * Get the adjacency list of the graph
      *
-     * @return true if graph is DAG, false otherwise
+     * @return Adjacency list
      */
-    public boolean isDAG() {
-        boolean[] visited = new boolean[vertices];
-        boolean[] recursionStack = new boolean[vertices];
+    public List<List<Integer>> getAdjList() {
+        return adjList;
+    }
 
-        for (int i = 0; i < vertices; i++) {
-            if (!visited[i]) {
-                if (hasCycleDFS(i, visited, recursionStack)) {
-                    return false;
-                }
-            }
-        }
-        return true;
+    /**
+     * Get the number of vertices in the graph
+     *
+     * @return Number of vertices
+     */
+    public int getVertices() {
+        return vertices;
     }
 }

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

@@ -4,6 +4,7 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+
 import java.util.List;
 import org.junit.jupiter.api.Test;