Disjoint Sets

Week 12, Monday

March 23, 2026

Announcements

• PA3 due Week 12
• PEX5 this week!

A Disjoint Sets Example

Let R be an equivalence relation on the set of students in this room, where (s, t) ∈ R if s and t have the same favorite among {AC, FN, FB, TR, CC, CR, PMC, ___}.

Operations We’d Like to Facilitate

1. find(4)
2. find(4) == find(8)
3. if find(7) != find(2): union(find(7), find(2))

find(4) returns the representative of the set containing 4. find(4)==find(8) tests whether 4 and 8 are in the same set. The third operation merges two sets if they’re different.

Disjoint Sets ADT

We will implement a data structure in support of “Disjoint Sets”:

• Maintains a collection S = {s₀, s₁, … s_k} of disjoint sets.
• Each set has a representative member.
• Supports functions:

 

make_set(k) — creates a new set containing only k

union(k1, k2) — merges the sets containing k1 and k2

find(k) — returns the representative of the set containing k

A First Data Structure for Disjoint Sets

 

Find: __________

Union: __________

Find is O(1) — just look up the array. Union is O(n) — have to update all elements in one set to point to the new representative.

A Better Data Structure: UpTrees

• If array value is -1, then we’ve found a root; otherwise value is the index of the parent.
• x and y are in the same uptree iff they are in the same set.

Draw two examples on the board: (1) All singletons: [-1, -1, -1, -1]. Four separate roots. (2) After some unions, e.g., union(0,1) and union(2,3): [−1, 0, −1, 2]. Two trees of size 2.

Example: Partition of Elements into Disjoint Sets

Roots store -1. Non-roots store the index of their parent. find(1) → s[1]=8 → s[8]=4 → s[4]=-1 → return 4. find(3) → s[3]=6 → s[6]=-1 → return 6.

UpTree Implementation

def find(self, i):
    if self.s[i] < 0:
        return i
    else:
        return self.find(self.s[i])

Running time depends on ___________.

Worst case? ___________

What’s an ideal tree? ___________

def union(self, root1, root2):
    self.s[root2] = root1

Running time of find depends on the height of the tree. Worst case is O(n) — a degenerate chain. Ideal tree is short and wide (star-shaped). Union as shown is naive — it can create tall trees.

Smart Unions

Both of these schemes for Union guarantee the height of the tree is ________.

Both guarantee O(log n) height. Union by height: attach shorter tree under taller tree’s root. Union by size: attach smaller tree under larger tree’s root. Both yield O(log n) for find.

Smart Unions: Implementation

def find(self, i):
    if self.s[i] < 0:
        return i
    else:
        return self.find(self.s[i])

def union_by_size(self, root1, root2):
    new_size = self.s[root1] + self.s[root2]
    if self.s[root1] <= self.s[root2]:   # root1 is bigger (more negative)
        self.s[root2] = root1
        self.s[root1] = new_size
    else:
        self.s[root1] = root2
        self.s[root2] = new_size

Roots store the negative of the set size (e.g., -3 means 3 elements). When merging, the smaller tree becomes a child of the larger tree’s root. The new root updates its size to the combined total.

Summary

UpTree implementation of ADT Disjoint Sets with smart Union gives:

• Find: \(O(\log n)\)
• Union: \(O(1)\)

 

Can we do better?