Union–find & dynamic connectivity

The dynamic connectivity problem

Maintain disjoint components of objects numbered 0 through n−1. A union operation joins two components, and a find operation identifies the component containing an object. Two objects are connected when their representatives agree.

Connectivity is reflexive, symmetric and transitive, so it partitions the objects into equivalence classes. We need component membership, not a list of every path connecting two objects.

Quick-find: eager labels

Store a component identifier in id[p] for every object p. Find reads one entry. To union p and q, save both original labels and scan the entire array, changing entries matching p’s old label to q’s label.

A find is Θ(1), while a union that scans the array is Θ(n). A sequence of n such unions can therefore require Θ(n²) work. Saving the old label before changing entries is essential for a correct update.

• Initial state for five objects: [0, 1, 2, 3, 4].
• union(0, 1): [1, 1, 2, 3, 4].
• union(1, 2): [2, 2, 2, 3, 4].
• connected(0, 2) is true because both labels are 2.

Quick-union: parent-pointer forests

Interpret parent[p] as a link toward a root. A root points to itself. Find follows links until reaching a root; union makes one root point to the other. The structure represents a forest of trees.

Unweighted linking can create a chain of length n−1. Both find and union can take Θ(n) in the worst case. The fact that union changes only one pointer does not make its root searches constant time.

Weighted union bounds the height

Keep the size of each tree at its root. Attach the smaller tree’s root beneath the larger tree’s root. The depth of a node increases only when its tree is attached to another tree at least as large, so the containing component at least doubles.

After a node’s depth increases k times, its tree contains at least 2ᵏ nodes. Since it contains at most n nodes, k ≤ log₂ n. Thus find and union have O(log n) worst-case time, using Θ(n) storage.

Path compression and amortized cost

After locating a root, full path compression redirects the visited nodes directly to that root. Path halving is another variant that redirects links toward grandparents while searching. The supplied files contain different variants; do not silently treat them as identical implementations.

Weighting with compression gives extremely slow-growing amortized operation cost, conventionally expressed using the inverse Ackermann function α(n). This is a bound over a sequence, not a promise that every individual operation takes a fixed number of steps. Include Θ(n) initialization when measuring a complete run.

Application: percolation

The source models an n-by-n grid of blocked or open sites. When a site opens, connect it to adjacent open sites. The system percolates when an open path connects the top row to the bottom row.

Virtual top and bottom sites reduce the percolation query to a connectivity query. Randomly opening sites until percolation occurs gives one Monte Carlo estimate of the threshold; repeat trials to study variation. The lecture’s approximate threshold is a simulation result for its specified square-lattice model.

The supplied Percolation.java actually uses recursive depth-first search to mark open sites reachable from the top, rather than the slides’ union–find implementation. It computes a fresh reachability matrix for the query. These are two different solutions to the same connectivity question.

As a supplementary caution for the virtual-site approach, one union–find structure using both virtual sites can produce backwash when testing fullness after percolation. Distinguish a percolation test from a test of whether an individual site is connected to the top.

Choosing an implementation

Quick-find makes lookup cheap by making updates expensive. Quick-union delays work but can grow deep trees. Weighting controls tree height; path compression speeds later operations. Always name the variant when quoting a bound.

Original implementations

Read the complete original code and its documentation. Core algorithm pages add a walkthrough, complexity discussion and a worked example.

Check your understanding

Supplementary practice. Try each question before opening the answer.