feat: Add Topological Sorting using DFS

Author: gowtham1412-p

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

@@ -0,0 +1,149 @@
+package com.thealgorithms.graphs;
+
+import java.util.*;
+
+/**
+ * Topological Sorting using Depth-First Search (DFS)
+ * 
+ * Topological sorting for Directed Acyclic Graph (DAG) is a linear ordering 
+ * of vertices such that for every directed edge u -> v, vertex u comes before v.
+ * 
+ * Time Complexity: O(V + E)
+ * Space Complexity: O(V)
+ * 
+ * @author gowtham1412-p
+ */
+public class TopologicalSortDFS {
+    
+    private int vertices;
+    private List<List<Integer>> adjList;
+    
+    /**
+     * Constructor to initialize the graph
+     * 
+     * @param vertices Number of vertices in the graph
+     */
+    public TopologicalSortDFS(int vertices) {
+        this.vertices = vertices;
+        this.adjList = new ArrayList<>(vertices);
+        for (int i = 0; i < vertices; i++) {
+            adjList.add(new ArrayList<>());
+        }
+    }
+    
+    /**
+     * Add a directed edge to the graph
+     * 
+     * @param source Source vertex
+     * @param destination Destination vertex
+     */
+    public void addEdge(int source, int destination) {
+        if (source < 0 || source >= vertices || destination < 0 || destination >= vertices) {
+            throw new IllegalArgumentException("Invalid vertex");
+        }
+        adjList.get(source).add(destination);
+    }
+    
+    /**
+     * Performs topological sort using DFS
+     * 
+     * @return List of vertices in topological order
+     * @throws IllegalArgumentException if graph contains a cycle
+     */
+    public List<Integer> topologicalSort() {
+        boolean[] visited = new boolean[vertices];
+        boolean[] recursionStack = new boolean[vertices];
+        Stack<Integer> stack = new Stack<>();
+        
+        // Check for cycles and perform DFS
+        for (int i = 0; i < vertices; i++) {
+            if (!visited[i]) {
+                if (hasCycleDFS(i, visited, recursionStack)) {
+                    throw new IllegalArgumentException("Graph contains a cycle. Topological sort not possible.");
+                }
+            }
+        }
+        
+        // Reset visited for actual topological sort
+        Arrays.fill(visited, false);
+        
+        // Perform DFS to get topological order
+        for (int i = 0; i < vertices; i++) {
+            if (!visited[i]) {
+                topologicalSortDFS(i, visited, stack);
+            }
+        }
+        
+        // Convert stack to list
+        List<Integer> result = new ArrayList<>();
+        while (!stack.isEmpty()) {
+            result.add(stack.pop());
+        }
+        
+        return result;
+    }
+    
+    /**
+     * DFS helper method to detect cycles
+     * 
+     * @param vertex Current vertex
+     * @param visited Visited array
+     * @param recursionStack Recursion stack to detect back edges
+     * @return true if cycle exists, false otherwise
+     */
+    private boolean hasCycleDFS(int vertex, boolean[] visited, boolean[] recursionStack) {
+        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
+            }
+        }
+        
+        recursionStack[vertex] = false;
+        return false;
+    }
+    
+    /**
+     * DFS helper method for topological sort
+     * 
+     * @param vertex Current vertex
+     * @param visited Visited array
+     * @param stack Stack to store topological order
+     */
+    private void topologicalSortDFS(int vertex, boolean[] visited, Stack<Integer> stack) {
+        visited[vertex] = true;
+        
+        for (int neighbor : adjList.get(vertex)) {
+            if (!visited[neighbor]) {
+                topologicalSortDFS(neighbor, visited, stack);
+            }
+        }
+        
+        stack.push(vertex);
+    }
+    
+    /**
+     * Check if the graph is a DAG (Directed Acyclic Graph)
+     * 
+     * @return true if graph is DAG, false otherwise
+     */
+    public boolean isDAG() {
+        boolean[] visited = new boolean[vertices];
+        boolean[] recursionStack = new boolean[vertices];
+        
+        for (int i = 0; i < vertices; i++) {
+            if (!visited[i]) {
+                if (hasCycleDFS(i, visited, recursionStack)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,150 @@
+package com.thealgorithms.graphs;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Test cases for TopologicalSortDFS
+ * 
+ * @author gowtham1412-p
+ */
+class TopologicalSortDFSTest {
+    
+    @Test
+    void testSimpleDAG() {
+        TopologicalSortDFS graph = new TopologicalSortDFS(6);
+        graph.addEdge(5, 2);
+        graph.addEdge(5, 0);
+        graph.addEdge(4, 0);
+        graph.addEdge(4, 1);
+        graph.addEdge(2, 3);
+        graph.addEdge(3, 1);
+        
+        List<Integer> result = graph.topologicalSort();
+        
+        // Verify the order is valid
+        assertTrue(isValidTopologicalOrder(result, new int[][]{{5,2}, {5,0}, {4,0}, {4,1}, {2,3}, {3,1}}));
+    }
+    
+    @Test
+    void testLinearGraph() {
+        TopologicalSortDFS graph = new TopologicalSortDFS(4);
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 3);
+        
+        List<Integer> result = graph.topologicalSort();
+        assertEquals(Arrays.asList(0, 1, 2, 3), result);
+    }
+    
+    @Test
+    void testSingleVertex() {
+        TopologicalSortDFS graph = new TopologicalSortDFS(1);
+        List<Integer> result = graph.topologicalSort();
+        assertEquals(Arrays.asList(0), result);
+    }
+    
+    @Test
+    void testDisconnectedGraph() {
+        TopologicalSortDFS graph = new TopologicalSortDFS(4);
+        graph.addEdge(0, 1);
+        graph.addEdge(2, 3);
+        
+        List<Integer> result = graph.topologicalSort();
+        assertEquals(4, result.size());
+    }
+    
+    @Test
+    void testCycleDetection() {
+        TopologicalSortDFS graph = new TopologicalSortDFS(3);
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 0); // Creates a cycle
+        
+        assertThrows(IllegalArgumentException.class, () -> {
+            graph.topologicalSort();
+        });
+    }
+    
+    @Test
+    void testSelfLoop() {
+        TopologicalSortDFS graph = new TopologicalSortDFS(3);
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 1); // Self loop
+        
+        assertThrows(IllegalArgumentException.class, () -> {
+            graph.topologicalSort();
+        });
+    }
+    
+    @Test
+    void testIsDAG() {
+        TopologicalSortDFS graph = new TopologicalSortDFS(4);
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 3);
+        
+        assertTrue(graph.isDAG());
+    }
+    
+    @Test
+    void testIsNotDAG() {
+        TopologicalSortDFS graph = new TopologicalSortDFS(3);
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 0);
+        
+        assertFalse(graph.isDAG());
+    }
+    
+    @Test
+    void testInvalidVertex() {
+        TopologicalSortDFS graph = new TopologicalSortDFS(3);
+        
+        assertThrows(IllegalArgumentException.class, () -> {
+            graph.addEdge(-1, 0);
+        });
+        
+        assertThrows(IllegalArgumentException.class, () -> {
+            graph.addEdge(0, 5);
+        });
+    }
+    
+    @Test
+    void testComplexDAG() {
+        TopologicalSortDFS graph = new TopologicalSortDFS(8);
+        graph.addEdge(0, 3);
+        graph.addEdge(0, 4);
+        graph.addEdge(1, 3);
+        graph.addEdge(2, 4);
+        graph.addEdge(2, 7);
+        graph.addEdge(3, 5);
+        graph.addEdge(3, 6);
+        graph.addEdge(3, 7);
+        graph.addEdge(4, 6);
+        
+        List<Integer> result = graph.topologicalSort();
+        
+        // Verify valid ordering
+        assertTrue(result.indexOf(0) < result.indexOf(3));
+        assertTrue(result.indexOf(3) < result.indexOf(5));
+        assertTrue(result.indexOf(4) < result.indexOf(6));
+    }
+    
+    /**
+     * Helper method to verify topological order
+     */
+    private boolean isValidTopologicalOrder(List<Integer> order, int[][] edges) {
+        for (int[] edge : edges) {
+            int u = edge[0];
+            int v = edge[1];
+            if (order.indexOf(u) > order.indexOf(v)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}