Minimum Spanning Trees

Week 14, Tuesday — Kruskal’s Algorithm

April 7, 2026

Announcements

MST (review)

Input: connected, undirected graph \(G\) with edge weights

Output: subgraph \(G'\) such that:

• \(G'\) spans \(G\) (contains all vertices)
• \(G'\) is connected and acyclic (a tree)
• \(G'\) has minimum total weight among all spanning trees

 

What is the MST of this graph?

Total weight = ____

MST edges: C-D(1), A-C(2), B-E(2), C-E(3), D-F(5). Total = 13. A tree on n vertices has exactly n-1 edges.

Kruskal’s Algorithm

(a,d)

(e,h)

(f,g)

(a,b)

(b,d)

(g,e)

(g,h)

(e,c)

(c,h)

(e,f)

(f,c)

(d,e)

(b,c)

(c,d)

(a,f)

(d,f)

Graph has 8 vertices, 16 edges. The sorted edge list on the right is keyed by weight (weights shown in graph). MST: (a,d)=2, (e,h)=2, (f,g)=4, (a,b)=5, (g,e)=8, (e,c)=10, (d,e)=13. Total = 44.

Kruskal’s Algorithm (1956)

(a,d)

(e,h)

(f,g)

(a,b)

(b,d)

(g,e)

(g,h)

(e,c)

(c,h)

(e,f)

(f,c)

(d,e)

(b,c)

(c,d)

(a,f)

(d,f)

1. Initialize graph \(T = (V, \emptyset)\) — all \(n\) vertices, no edges.

2. Initialize a disjoint sets structure where each vertex is its own set.

3. RemoveMin from PQ. If that edge connects two vertices from different sets, add the edge to \(T\) and take the Union of their sets; otherwise skip. Repeat until ____ edges are added to \(T\).

The blank is n-1 = 7 (for 8 vertices). The disjoint sets structure lets us check in nearly O(1) whether two vertices are already connected (same component). The key insight: Kruskal’s = greedy by edge weight + cycle detection via disjoint sets. Step 3 uses the cycle property: the max-weight edge on any cycle is never in the MST. Equivalently, adding an edge only if it connects two different components ensures no cycle is ever introduced.

Kruskal’s Algorithm: Pseudocode

def KruskalMST(G):
  forest = DisjointSets()
  for v in G.vertices:
    forest.makeSet(v)

  Q = PriorityQueue(G.edges, key=weight)

  T = []  # MST edges

  while len(T) < len(G.vertices) - 1:
    e = Q.removeMin()
    u, v = e.endpoints
    if forest.find(u) != forest.find(v):
      T.append(e)
      forest.smartUnion(
        forest.find(u), forest.find(v))

  return T

Input \(G = (V,E)\), \(|V| = n\), and \(|E| = m\).

 

Priority Queue:	Heap	Sorted Array
To build
Each removeMin

Priority queue is over edges (not vertices as in Prim’s). To build: - Heap: O(E) using buildHeap - Sorted array: O(E log E) to sort Each removeMin: - Heap: O(log E) - Sorted array: O(1) find + smartUnion: nearly O(1) amortized with path compression and union by rank.

Kruskal’s Algorithm: Runtime Analysis

def KruskalMST(G):
  forest = DisjointSets()
  for v in G.vertices:
    forest.makeSet(v)

  Q = PriorityQueue(G.edges, key=weight)

  T = []  # MST edges

  while len(T) < len(G.vertices) - 1:
    e = Q.removeMin()
    u, v = e.endpoints
    if forest.find(u) != forest.find(v):
      T.append(e)
      forest.smartUnion(
        forest.find(u), forest.find(v))

  return T

Priority Queue:	Total runtime: build + execute
Heap
Sorted Array

With a heap: - Build: O(E) - E removeMins × O(log E) each = O(E log E) - Total: O(E log E) With a sorted array: - Sort: O(E log E) - E removeMin at O(1) each = O(E) - Total: O(E log E) Both give O(E log E) = O(E log V) since E < V². For sparse graphs (E = O(V)): O(V log V). For dense (E = O(V²)): O(V² log V). Contrast Prim’s: heap + adj list = O(E log V) — same asymptotic for most graphs, but Prim’s can be O(V²) with unsorted array, useful for dense graphs.