Minimum Spanning Tree Kruskal's Algorithm in DSA Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a Minimum Spanning Tree (MST)?

A Minimum Spanning Tree is a subset of edges in a connected, weighted graph that connects all vertices together without any cycles and with the minimum possible total edge weight.

beginner

What is the main idea behind Kruskal's Algorithm?

Kruskal's Algorithm builds the MST by sorting all edges by weight and adding the smallest edge to the MST if it doesn't create a cycle, repeating until all vertices are connected.

intermediate

Why do we use a Union-Find (Disjoint Set) data structure in Kruskal's Algorithm?

Union-Find helps efficiently check if adding an edge creates a cycle by tracking which vertices are in the same connected component, allowing quick union and find operations.

intermediate

What is the time complexity of Kruskal's Algorithm?

The time complexity is O(E log E), where E is the number of edges, mainly due to sorting edges. Union-Find operations are almost constant time.

beginner

In Kruskal's Algorithm, what happens if adding an edge creates a cycle?

If adding an edge creates a cycle, the edge is skipped and not added to the MST to keep the tree structure without loops.

What is the first step in Kruskal's Algorithm?

A Sort all edges by their weight

B Pick any vertex as the starting point

C Create adjacency list

D Remove all cycles from the graph

Kruskal's Algorithm starts by sorting all edges from smallest to largest weight.

Which data structure is commonly used to detect cycles in Kruskal's Algorithm?

A Stack

B Union-Find (Disjoint Set)

C Queue

D Binary Search Tree

Union-Find efficiently tracks connected components to detect cycles.

What does Kruskal's Algorithm produce at the end?

A A shortest path tree

B A maximum spanning tree

C A cycle graph

D A minimum spanning tree

Kruskal's Algorithm produces a minimum spanning tree connecting all vertices with minimum total edge weight.

If an edge connects two vertices already in the same set, what should Kruskal's Algorithm do?

A Skip the edge to avoid cycle

B Add the edge to MST

C Remove one vertex

D Restart the algorithm

Adding such an edge would create a cycle, so it is skipped.

What is the main reason sorting edges is important in Kruskal's Algorithm?

A To find the longest path

B To build adjacency matrix

C To ensure the MST has minimum total weight

D To detect cycles faster

Sorting edges by weight ensures we pick the smallest edges first to minimize total MST weight.

Explain how Kruskal's Algorithm builds a Minimum Spanning Tree step-by-step.

Think about sorting edges and checking cycles before adding.

Describe the role of the Union-Find data structure in Kruskal's Algorithm and why it is important.

Focus on cycle detection and grouping vertices.

Practice

1. What is the main goal of Kruskal's Algorithm in graph theory?

easy

A. To find the minimum spanning tree of a connected weighted graph

B. To find the shortest path between two nodes

C. To detect cycles in a graph

D. To sort the vertices of a graph

Solution

1. Step 1: Understand the purpose of Kruskal's Algorithm

   Kruskal's Algorithm is designed to find a subset of edges that connects all vertices with the minimum total edge weight and no cycles.

2. Step 2: Compare with other graph algorithms

   Unlike shortest path or cycle detection algorithms, Kruskal's focuses on building a minimum spanning tree.

3. Final Answer:

   To find the minimum spanning tree of a connected weighted graph -> Option A

4. Quick Check:

   Minimum Spanning Tree = Find minimum edges connecting all nodes [OK]

Hint: Kruskal connects all nodes with least total edge weight [OK]

Common Mistakes:

• Confusing MST with shortest path
• Thinking it detects cycles only
• Assuming it sorts vertices

2. Which of the following TypeScript code snippets correctly initializes the edges array for Kruskal's Algorithm?

easy

A. const edges: number[][] = [0, 1, 10, 1, 2, 5, 0, 2, 15];

B. const edges = {0:1:10, 1:2:5, 0:2:15};

C. const edges: [number, number, number][] = [[0, 1, 10], [1, 2, 5], [0, 2, 15]];

D. const edges: Array<number> = [[0, 1, 10], [1, 2, 5], [0, 2, 15]];

Solution

1. Step 1: Check the correct TypeScript tuple array syntax

   Edges should be an array of tuples, each tuple having three numbers: [node1, node2, weight]. const edges: [number, number, number][] = [[0, 1, 10], [1, 2, 5], [0, 2, 15]]; uses this syntax correctly.

2. Step 2: Identify incorrect syntax in other options

   const edges = {0:1:10, 1:2:5, 0:2:15}; uses invalid object syntax. const edges: number[][] = [0, 1, 10, 1, 2, 5, 0, 2, 15]; is a flat array, not an array of tuples. const edges: Array<number> = [[0, 1, 10], [1, 2, 5], [0, 2, 15]]; uses wrong type annotation (Array<number> instead of tuple array).

3. Final Answer:

   const edges: [number, number, number][] = [[0, 1, 10], [1, 2, 5], [0, 2, 15]]; -> Option C

4. Quick Check:

   Tuple array syntax = const edges: [number, number, number][] = [[0, 1, 10], [1, 2, 5], [0, 2, 15]]; [OK]

Hint: Use tuple arrays for edges: [node1, node2, weight][] [OK]

Common Mistakes:

• Using flat arrays instead of tuples
• Wrong object syntax for edges
• Incorrect type annotations

3. What will be the output edges of the minimum spanning tree after running Kruskal's Algorithm on this graph?

const edges: [number, number, number][] = [[0, 1, 4], [0, 2, 3], [1, 2, 1], [1, 3, 2], [2, 3, 4], [3, 4, 2], [4, 5, 6]];

medium

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

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

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

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

Solution

1. Step 1: Sort edges by weight

   Sorted edges: [1,2,1], [1,3,2], [3,4,2], [0,2,3], [0,1,4], [2,3,4], [4,5,6]

2. Step 2: Pick edges without forming cycles until all nodes connected

   Pick [1,2,1], [1,3,2], [3,4,2], [0,2,3], and [4,5,6]. These connect all nodes with minimum total weight without cycles.

3. Final Answer:

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

4. Quick Check:

   Edges sorted + no cycles = [[1, 2, 1], [1, 3, 2], [3, 4, 2], [0, 2, 3], [4, 5, 6]] [OK]

Hint: Sort edges by weight, pick smallest without cycles [OK]

Common Mistakes:

• Choosing heavier edges first
• Including edges that form cycles
• Missing edges to connect all nodes

4. Identify the error in this TypeScript snippet implementing Kruskal's Algorithm:

const edges: [number, number, number][] = [[0,1,1],[1,2,2],[0,2,3]];
const parent = [0,1,2];
function find(x: number): number {
  if(parent[x] === x) return x;
  return find(parent[x]);
}
function union(a: number, b: number) {
  const rootA = find(a);
  const rootB = find(b);
  if(rootA !== rootB) parent[rootB] = rootA;
}
// Missing sorting of edges before processing

medium

A. The union function incorrectly assigns parent

B. The find function does not implement path compression

C. The parent array should be initialized with -1

D. The edges array is not sorted by weight before processing

Solution

1. Step 1: Check Kruskal's Algorithm requirements

   Kruskal's requires edges to be sorted by weight ascending before union-find operations.

2. Step 2: Identify missing sorting step

   The code comment notes missing sorting; without sorting, MST may not be minimal.

3. Final Answer:

   The edges array is not sorted by weight before processing -> Option D

4. Quick Check:

   Sorting edges first is essential [OK]

Hint: Always sort edges by weight before union-find steps [OK]

Common Mistakes:

• Skipping edge sorting
• Ignoring path compression (optional)
• Incorrect parent initialization

5. Given a graph with vertices 0 to 4 and edges:

[[0,1,10],[0,2,6],[0,3,5],[1,3,15],[2,3,4]]

Use Kruskal's Algorithm to find the total weight of the minimum spanning tree.

hard

A. 19

B. 20

C. 25

D. 15

Solution

1. Step 1: Sort edges by weight

   Sorted edges: [2,3,4], [0,3,5], [0,2,6], [0,1,10], [1,3,15]

2. Step 2: Pick edges without cycles until all vertices connected

   Pick [2,3,4], [0,3,5], [0,2,6] connect nodes 0,2,3. Then pick [0,1,10] to connect node 1. Total weight = 4+5+6+10 = 25. But this forms a cycle because 0,2,3 are connected. Instead, pick [2,3,4], [0,3,5], [0,1,10]. Then pick [0,2,6] creates cycle. So skip [0,2,6]. Next pick [1,3,15] is heavier and unnecessary. So MST edges: [2,3,4], [0,3,5], [0,1,10]. Total weight = 4+5+10=19.

3. Final Answer:

   19 -> Option A

4. Quick Check:

   Sum of MST edges weights = 19 [OK]

Hint: Sort edges, pick smallest without cycles, sum weights [OK]

Common Mistakes:

• Including edges that form cycles
• Adding all edges without checking
• Misordering edges by weight