Topological Sort Using Kahn's Algorithm BFS in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the in-degree array with zeros for all vertices.

DSA Javascript

const inDegree = new Array(V).fill([1]);

Drag options to blanks, or click blank then click option'

A0

B1

Cnull

Dundefined

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 instead of 0, which incorrectly assumes each vertex has an incoming edge.

Using null or undefined which are not numbers and cause errors.

We initialize the in-degree array with zeros because initially no edges have been processed.

2fill in blank

medium

Complete the code to increase the in-degree count for each neighbor in the adjacency list.

DSA Javascript

for (const neighbor of adj[node]) {
  inDegree[neighbor] [1] 1;
}

Drag options to blanks, or click blank then click option'

A-=

B+=

C*=

D/=

Attempts:

3 left

💡 Hint

Common Mistakes

Using -= which would decrease the count incorrectly.

Using *= or /= which are not appropriate for counting.

We add 1 to the in-degree of each neighbor because each edge increases the count of incoming edges.

3fill in blank

hard

Fix the error in the queue initialization to start with all vertices having zero in-degree.

DSA Javascript

const queue = [];
for (let i = 0; i < V; i++) {
  if (inDegree[i] [1] 0) {
    queue.push(i);
  }
}

Drag options to blanks, or click blank then click option'

A!=

B>

C===

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using != or > which would select wrong vertices.

Using < which is incorrect for this condition.

Vertices with zero in-degree have no dependencies and should be added to the queue to start processing.

4fill in blank

hard

Fill both blanks to correctly update in-degree and add new zero in-degree vertices to the queue.

DSA Javascript

while (queue.length > 0) {
  const node = queue.shift();
  result.push(node);
  for (const neighbor of adj[node]) {
    inDegree[neighbor] [1] 1;
    if (inDegree[neighbor] [2] 0) {
      queue.push(neighbor);
    }
  }
}

Drag options to blanks, or click blank then click option'

A-=

B+=

C===

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Increasing in-degree instead of decreasing.

Using incorrect comparison operators in the if condition.

We decrease the in-degree by 1 when an edge is removed and check if it becomes zero to add the vertex to the queue.

5fill in blank

hard

Fill all three blanks to complete the topological sort function using Kahn's Algorithm.

DSA Javascript

function kahnTopologicalSort(V, adj) {
  const inDegree = new Array(V).fill([1]);
  for (let i = 0; i < V; i++) {
    for (const neighbor of adj[i]) {
      inDegree[neighbor] [2] 1;
    }
  }
  const queue = [];
  for (let i = 0; i < V; i++) {
    if (inDegree[i] [3] 0) queue.push(i);
  }
  const result = [];
  while (queue.length > 0) {
    const node = queue.shift();
    result.push(node);
    for (const neighbor of adj[node]) {
      inDegree[neighbor] -= 1;
      if (inDegree[neighbor] === 0) queue.push(neighbor);
    }
  }
  return result;
}

Drag options to blanks, or click blank then click option'

A0

B+=

C===

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong operators for increment or comparison.

Not initializing in-degree correctly.

Initialize in-degree with 0, increment in-degree for neighbors, and enqueue vertices with zero in-degree.

Practice

1. What is the main purpose of Kahn's Algorithm in graph theory?

easy

A. To find a topological ordering of a Directed Acyclic Graph (DAG)

B. To find the shortest path between two nodes

C. To detect cycles in an undirected graph

D. To calculate the minimum spanning tree

Solution

1. Step 1: Understand Kahn's Algorithm goal

   Kahn's Algorithm is designed to produce a linear ordering of vertices in a Directed Acyclic Graph (DAG) such that for every directed edge u -> v, u comes before v in the ordering.

2. Step 2: Compare with other graph algorithms

   Other algorithms like shortest path or minimum spanning tree serve different purposes, so they do not match Kahn's Algorithm's goal.

3. Final Answer:

   To find a topological ordering of a Directed Acyclic Graph (DAG) -> Option A

4. Quick Check:

   Topological sort = Kahn's Algorithm purpose [OK]

Hint: Kahn's Algorithm always orders DAG nodes topologically [OK]

Common Mistakes:

• Confusing topological sort with shortest path
• Thinking it works on undirected graphs
• Assuming it detects cycles directly

2. Which of the following is the correct way to initialize the queue in Kahn's Algorithm in JavaScript?

easy

A. const queue = []; // Push all nodes with indegree 0

B. const queue = new Set(); // Add all nodes with indegree 0

C. const queue = {}; // Store nodes with indegree 0 as keys

D. const queue = null; // Initialize empty queue

Solution

1. Step 1: Identify queue data structure for BFS

   Kahn's Algorithm uses a queue to process nodes with indegree 0 in order. In JavaScript, an array is commonly used as a queue by pushing and shifting elements.

2. Step 2: Evaluate options

   const queue = []; // Push all nodes with indegree 0 correctly initializes an empty array to be used as a queue. const queue = new Set(); // Add all nodes with indegree 0 uses a Set which does not guarantee order. const queue = {}; // Store nodes with indegree 0 as keys uses an object which is not suitable as a queue. const queue = null; // Initialize empty queue initializes null which is invalid.

3. Final Answer:

   const queue = []; // Push all nodes with indegree 0 -> Option A

4. Quick Check:

   Queue = array for BFS in Kahn's Algorithm [OK]

Hint: Use array as queue with push and shift in JavaScript [OK]

Common Mistakes:

• Using Set which does not preserve order
• Using object instead of queue
• Initializing queue as null

3. What will be the output of the following code snippet implementing Kahn's Algorithm on the graph edges [[5, 2], [5, 0], [4, 0], [4, 1], [2, 3], [3, 1]]?

function kahnTopoSort(edges) {
  const graph = {};
  const indegree = {};
  const nodes = new Set();

  edges.forEach(([u, v]) => {
    nodes.add(u);
    nodes.add(v);
    if (!graph[u]) graph[u] = [];
    graph[u].push(v);
    indegree[v] = (indegree[v] || 0) + 1;
    if (!(u in indegree)) indegree[u] = 0;
  });

  const queue = [];
  nodes.forEach(node => {
    if (indegree[node] === 0) queue.push(node);
  });

  const result = [];
  while (queue.length) {
    const node = queue.shift();
    result.push(node);
    (graph[node] || []).forEach(nei => {
      indegree[nei]--;
      if (indegree[nei] === 0) queue.push(nei);
    });
  }

  return result;
}

console.log(kahnTopoSort([[5, 2], [5, 0], [4, 0], [4, 1], [2, 3], [3, 1]]));

medium

A. [5, 4, 0, 2, 3, 1]

B. [4, 5, 0, 2, 3, 1]

C. [5, 4, 2, 0, 3, 1]

D. [4, 5, 2, 3, 1, 0]

Solution

1. Step 1: Build graph and indegree map

   Edges create graph: 5->2,5->0,4->0,4->1,2->3,3->1. Indegree counts: 5=0,4=0,2=1,3=1,1=2,0=2.

2. Step 2: Process nodes with indegree 0 and update

   Start queue with [5,4]. Remove 5: result=[5], decrease indegree of 2 and 0. 2 indegree=0, 0 indegree=1. Queue=[4,2]. Remove 4: result=[5,4], decrease indegree of 0 and 1. 0 indegree=0, 1 indegree=1. Queue=[2,0]. Remove 2: result=[5,4,2], decrease indegree of 3. 3 indegree=0. Queue=[0,3]. Remove 0: result=[5,4,2,0], no neighbors. Queue=[3]. Remove 3: result=[5,4,2,0,3], decrease indegree of 1. 1 indegree=0. Queue=[1]. Remove 1: result=[5,4,2,0,3,1]. Queue empty.

3. Final Answer:

   [5, 4, 2, 0, 3, 1] -> Option C

4. Quick Check:

   Topological order = [5,4,2,0,3,1] [OK]

Hint: Track indegree zero nodes and update after removing each node [OK]

Common Mistakes:

• Not updating indegree correctly
• Wrong initial queue nodes
• Mixing order of nodes with same indegree

4. Identify the bug in this Kahn's Algorithm implementation snippet:

function kahnTopoSort(edges) {
  const graph = {};
  const indegree = {};
  edges.forEach(([u, v]) => {
    if (!graph[u]) graph[u] = [];
    graph[u].push(v);
    indegree[v] = (indegree[v] || 0) + 1;
  });
  const queue = [];
  for (const node in graph) {
    if (!indegree[node]) queue.push(node);
  }
  const result = [];
  while (queue.length) {
    const node = queue.shift();
    result.push(node);
    (graph[node] || []).forEach(nei => {
      indegree[nei]--;
      if (indegree[nei] === 0) queue.push(nei);
    });
  }
  return result;
}

medium

A. Graph edges are not added properly to adjacency list

B. Nodes with zero indegree not correctly identified because some nodes are missing in indegree

C. Queue is initialized incorrectly as an object instead of array

D. The while loop condition should be queue.length > 1

Solution

1. Step 1: Check indegree initialization

   Indegree is only set for nodes that appear as destination (v). Nodes that only appear as source (u) are missing in indegree, so their indegree is undefined, not zero.

2. Step 2: Identify impact on queue initialization

   The queue initialization only loops over keys in the graph object (nodes with outgoing edges). Nodes with zero indegree but no outgoing edges (e.g., isolated nodes) are missing from both the graph and indegree, so not correctly identified.

3. Final Answer:

   Nodes with zero indegree not correctly identified because some nodes are missing in indegree -> Option B

4. Quick Check:

   Indegree missing nodes cause wrong zero indegree detection [OK]

Hint: Initialize indegree for all nodes before queue setup [OK]

Common Mistakes:

• Not initializing indegree for all nodes
• Using wrong loop condition in while
• Incorrect queue data structure

5. Given a graph with edges [[1, 2], [1, 3], [3, 4], [2, 4], [4, 5], [6, 3]], how can you modify Kahn's Algorithm to detect if the graph contains a cycle?

hard

A. Add a visited set and mark nodes visited during BFS; if revisited, cycle exists

B. Count edges and compare with nodes; if edges > nodes, cycle exists

C. Use a stack instead of queue to detect cycles during processing

D. Check if the number of nodes processed is less than total nodes; if yes, a cycle exists

Solution

1. Step 1: Understand Kahn's Algorithm cycle detection

   Kahn's Algorithm processes nodes with zero indegree. If a cycle exists, some nodes will never reach zero indegree and thus won't be processed.

2. Step 2: Detect cycle by comparing processed nodes count

   If the count of processed nodes is less than total nodes, it means some nodes are stuck in a cycle and were never processed, indicating a cycle.

3. Final Answer:

   Check if the number of nodes processed is less than total nodes; if yes, a cycle exists -> Option D

4. Quick Check:

   Processed nodes < total nodes means cycle [OK]

Hint: Compare processed nodes count with total nodes to find cycles [OK]

Common Mistakes:

• Using visited set which is for DFS, not Kahn's Algorithm
• Using stack instead of queue incorrectly
• Comparing edges and nodes count wrongly