[FEATURE]: Add Kahn's Algorithm in Graphs #1795

Author: Virus2hell

Graphs/KahnsAlgorithm.js

@@ -0,0 +1,62 @@
+/**
+ * Kahn's Algorithm for Topological Sorting (BFS-based)
+ *
+ * Time Complexity: O(V + E)
+ * Space Complexity: O(V + E)
+ *
+ * Usage:
+ * const V = 6;
+ * const edges = [
+ *   [5, 2],
+ *   [5, 0],
+ *   [4, 0],
+ *   [4, 1],
+ *   [2, 3],
+ *   [3, 1]
+ * ];
+ * const order = kahnTopologicalSort(V, edges);
+ * console.log(order);
+ *
+ * Returns:
+ *  - A valid topological order of the graph if DAG,
+ *  - [] if graph contains a cycle.
+ */
+
+function kahnTopologicalSort(V, edges) {
+  // Build adjacency list and indegree array
+  const adj = Array.from({ length: V }, () => []);
+  const indegree = new Array(V).fill(0);
+
+  for (const [u, v] of edges) {
+    if (u < 0 || u >= V || v < 0 || v >= V) {
+      throw new Error('Edge contains vertex outside range 0..V-1');
+    }
+    adj[u].push(v);
+    indegree[v]++;
+  }
+
+  // Initialize queue with nodes of indegree 0
+  const queue = [];
+  for (let i = 0; i < V; i++) {
+    if (indegree[i] === 0) queue.push(i);
+  }
+
+  const topoOrder = [];
+  let idx = 0;
+  while (idx < queue.length) {
+    const node = queue[idx++]; // treat array as queue
+    topoOrder.push(node);
+
+    for (const nei of adj[node]) {
+      indegree[nei]--;
+      if (indegree[nei] === 0) queue.push(nei);
+    }
+  }
+
+  // If topoOrder size != V, graph has a cycle
+  if (topoOrder.length !== V) return [];
+
+  return topoOrder;
+}
+
+module.exports = { kahnTopologicalSort };

Graphs/test/KahnsAlgorithm.test.js

@@ -0,0 +1,53 @@
+const { kahnTopologicalSort } = require('../KahnsAlgorithm');
+
+describe("Kahn's Algorithm - Topological Sort", () => {
+  test('returns a valid topological order for a DAG', () => {
+    const V = 6;
+    const edges = [
+      [5, 2],
+      [5, 0],
+      [4, 0],
+      [4, 1],
+      [2, 3],
+      [3, 1],
+    ];
+
+    const order = kahnTopologicalSort(V, edges);
+    expect(order.length).toBe(V);
+
+    // verify topological property
+    const pos = new Array(V);
+    for (let i = 0; i < order.length; i++) pos[order[i]] = i;
+
+    for (const [u, v] of edges) {
+      expect(pos[u]).toBeLessThan(pos[v]);
+    }
+  });
+
+  test('returns empty array when graph contains a cycle', () => {
+    const V = 3;
+    const edges = [
+      [0, 1],
+      [1, 2],
+      [2, 0] // cycle
+    ];
+    const order = kahnTopologicalSort(V, edges);
+    expect(order).toEqual([]);
+  });
+
+  test('handles isolated nodes', () => {
+    const V = 4;
+    const edges = [
+      [0, 1],
+      [2, 3]
+    ];
+    const order = kahnTopologicalSort(V, edges);
+    expect(order.length).toBe(4);
+
+    const pos = new Array(V);
+    for (let i = 0; i < order.length; i++) pos[order[i]] = i;
+    for (const [u, v] of edges) {
+      expect(pos[u]).toBeLessThan(pos[v]);
+    }
+  });
+});