Added Kann's algorithm

Graphs/KahnsAlgorithm.js

@@ -0,0 +1,45 @@
+import Queue from '../Data-Structures/Queue/Queue'
+
+/**
+ * @author {RaviSadam}
+ * @name KahnsAlgorithm
+ * @description -
+ * Kahn's Algorithm implementation in JavaScript
+ * @summary
+ * Kahn's Algorithm is used for finding the topological sorting order of directed acyclic graph
+ *
+ * @param graph - Graph (adjacency list)
+ * @param n - Size of graph
+ * @returns {Array} - null if cycle is detected or else result array
+ *
+ */
+
+export function KahnsAlgorithm(graph, n) {
+  if (n === null || n === undefined) throw Error('Invalid n was given')
+  const inDegree = Array(n).fill(0)
+  const result = []
+  for (const neighbours of graph) {
+    for (const neighbour of neighbours) {
+      inDegree[neighbour] += 1
+    }
+  }
+  const queue = new Queue()
+
+  for (let i = 0; i < n; i++) {
+    if (inDegree[i] === 0) {
+      queue.enqueue(i)
+    }
+  }
+  while (queue.length !== 0) {
+    const node = queue.dequeue()
+    result.push(node)
+    for (const neighbour of graph[node]) {
+      inDegree[neighbour] -= 1
+      if (inDegree[neighbour] == 0) {
+        queue.enqueue(neighbour)
+      }
+    }
+  }
+  if (result.length !== n) return null
+  return result
+}

Graphs/KannsAlgorithm.js

@@ -0,0 +1,44 @@
+/**
+ * @author {RaviSadam}
+ * @name kannsAlgorithm
+ * @description -
+ * Kann's Algorithm implementation in JavaScript
+ * @summary
+ * Kann's Algorithm is used for topological sorting in directed acyclic graphs
+ *
+ * @param graph - Graph [[v1,v2],[v3,v4,v5]..]
+ * @param n - number of vertices
+ * @returns {Array} - Empty array if cycle is detected or else result array;
+ *
+ */
+
+export function kannsAlgorithm(graph, n) {
+  if (n === null || n === undefined) throw Error('Invalid n was given')
+  const inorder = Array(n).fill(0)
+  const result = []
+  for (let entry of graph) {
+    for (let edge of entry) {
+      inorder[edge] += 1
+    }
+  }
+  const queue = []
+  console.log(inorder)
+  for (let i = 0; i < n; i++) {
+    if (inorder[i] === 0) {
+      queue.push(i)
+    }
+  }
+  while (queue.length != 0) {
+    const node = queue[0]
+    result.push(node)
+    queue.splice(0, 1)
+    for (let nei of graph[node]) {
+      inorder[nei] -= 1
+      if (inorder[nei] == 0) {
+        queue.push(nei)
+      }
+    }
+  }
+  if (result.length != n) return []
+  return result
+}

Graphs/test/KahnsAlgorithm.test.js

@@ -0,0 +1,13 @@
+import { KahnsAlgorithm } from '../KahnsAlgorithm'
+
+test('Graph without cycle', () => {
+  const graph = [[], [], [3], [1], [0, 1], [0, 2]]
+
+  expect(KahnsAlgorithm(graph, 6)).toEqual([4, 5, 0, 2, 3, 1])
+})
+
+test('Graph with cycle', () => {
+  const graph = [[2], [], [3, 5], [0, 1], [0, 2]]
+
+  expect(KahnsAlgorithm(graph, 6)).toBe(null)
+})

Graphs/test/KannsAlgorithm.test.js

@@ -0,0 +1,13 @@
+import { kannsAlgorithm } from '../KannsAlgorithm'
+
+test('Test Case 1: Graph without cycle', () => {
+  const graph = [[], [], [3], [1], [0, 1], [0, 2]]
+
+  expect(kannsAlgorithm(graph, 6)).toEqual([4, 5, 0, 2, 3, 1])
+})
+
+test('Test Case 2: Graph with cycle', () => {
+  const graph = [[2], [], [3, 5], [0, 1], [0, 2]]
+
+  expect(kannsAlgorithm(graph, 6)).toEqual([])
+})