Added Topological Sort using DFS

Author: Mansi5164

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

@@ -0,0 +1,54 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * Implementation of Topological Sort using Depth-First Search (DFS).
+ *
+ * <p>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
+ * in the ordering.
+ */
+public final class TopologicalSortDFS {
+
+    // Private constructor to prevent instantiation
+    private TopologicalSortDFS() {
+        throw new AssertionError("Cannot instantiate utility class");
+    }
+
+    /**
+     * Performs topological sorting on a directed acyclic graph.
+     *
+     * @param vertices the number of vertices in the graph
+     * @param adjacencyList the adjacency list representing the graph
+     * @return a list containing vertices in topologically sorted order
+     */
+    public static List<Integer> topologicalSort(int vertices, List<List<Integer>> adjacencyList) {
+        boolean[] visited = new boolean[vertices];
+        Stack<Integer> stack = new Stack<>();
+
+        for (int i = 0; i < vertices; i++) {
+            if (!visited[i]) {
+                dfs(i, visited, stack, adjacencyList);
+            }
+        }
+
+        List<Integer> result = new ArrayList<>();
+        while (!stack.isEmpty()) {
+            result.add(stack.pop());
+        }
+        return result;
+    }
+
+    private static void dfs(int node, boolean[] visited, Stack<Integer> stack, List<List<Integer>> adjacencyList) {
+        visited[node] = true;
+        for (int neighbor : adjacencyList.get(node)) {
+            if (!visited[neighbor]) {
+                dfs(neighbor, visited, stack, adjacencyList);
+            }
+        }
+        stack.push(node);
+    }
+}

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

@@ -0,0 +1,44 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for {@link TopologicalSortDFS}.
+ */
+public final class TopologicalSortDFSTest {
+
+    @Test
+    void testSimpleGraph() {
+        int vertices = 6;
+        List<List<Integer>> adjacencyList = new ArrayList<>();
+        for (int i = 0; i < vertices; i++) {
+            adjacencyList.add(new ArrayList<>());
+        }
+
+        adjacencyList.get(5).add(2);
+        adjacencyList.get(5).add(0);
+        adjacencyList.get(4).add(0);
+        adjacencyList.get(4).add(1);
+        adjacencyList.get(2).add(3);
+        adjacencyList.get(3).add(1);
+
+        List<Integer> result = TopologicalSortDFS.topologicalSort(vertices, adjacencyList);
+
+        // A valid topological order is one of the possible ones
+        List<Integer> expected = Arrays.asList(5, 4, 2, 3, 1, 0);
+        Assertions.assertTrue(result.containsAll(expected) && expected.containsAll(result));
+    }
+
+    @Test
+    void testEmptyGraph() {
+        int vertices = 0;
+        List<List<Integer>> adjacencyList = new ArrayList<>();
+        List<Integer> result = TopologicalSortDFS.topologicalSort(vertices, adjacencyList);
+        Assertions.assertTrue(result.isEmpty());
+    }
+}