Disjoint Sets Continued

Week 12, Tuesday

March 24, 2026

Announcements

• PA3 due Week 12
• PEX5 this week!

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?

Path Compression

Path compression: when Find(i) traverses the path to the root, set every node along that path to point directly to the root. This flattens the tree, making all future finds faster. E.g., after Find(5), nodes 5, 4, 2, 7, 9 all point directly to root 10.

Analysis

Something we’ll need — Iterated log:

\[\log^* (n) = \begin{cases} 0 & \text{if } n \leq 1 \\ 1 + \log^*(\log n) & \text{if } n > 1 \end{cases}\]

Example: \(\log^* (2^{65536})\)

Relevant result: In an upTree implementation of Disjoint Sets using smart union and find with path compression…

any sequence of \(m\) union and find operations results in worst case running time of \(O(\_\_\_\_\_\_\_\_\_\_)\), where \(n\) is the number of items.

http://research.cs.vt.edu/AVresearch/UF/

log(n) is the iterated logarithm — the number of times you apply log before the value drops to ≤ 1. For n = 2^65536 (an astronomically large number), log(n) = 5. So log* is effectively constant for all practical n. The result: any m union+find operations with path compression + smart union run in O(m log* n) total — essentially O(m) amortized.

Summary

UpTree implementation of ADT Disjoint Sets with smart Union gives:

• Find = O(log n)
• Union = O(1)

 

If we add path compression we achieve nearly constant time for both operations.