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

Author: Virus2hell

Graphs/KahnsAlgorithm.js

@@ -23,19 +23,14 @@
  */
 
 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);
@@ -44,7 +39,7 @@ function kahnTopologicalSort(V, edges) {
   const topoOrder = [];
   let idx = 0;
   while (idx < queue.length) {
-    const node = queue[idx++]; // treat array as queue
+    const node = queue[idx++];
     topoOrder.push(node);
 
     for (const nei of adj[node]) {
@@ -53,10 +48,10 @@ function kahnTopologicalSort(V, edges) {
     }
   }
 
-  // If topoOrder size != V, graph has a cycle
+  // Return empty array if cycle detected
   if (topoOrder.length !== V) return [];
-
   return topoOrder;
 }
 
 module.exports = { kahnTopologicalSort };
+

Graphs/test/KahnsAlgorithm.test.js

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