Course navigation & on this page
Quick-find
Maintain an eager component label for every object.
Overview
Maintain an eager component label for every object. Find reads a label, but union scans the labels to relabel an entire component. Initialization also touches all n entries.
Step-by-step walkthrough
- Initialize id[i] = i.
- Find returns id[p].
- Union saves both component labels.
- Replace every occurrence of the first label with the second.
Complexity analysis
| Best case | Find Θ(1) |
|---|---|
| Average / aggregate | Union Θ(n) when scanning |
| Worst case | Union Θ(n) |
| Space | Θ(n) |
Find reads a label, but union scans the labels to relabel an entire component. Initialization also touches all n entries.
A worked example
[0,1,2,3] → union(0,1) → [1,1,2,3] → union(1,2) → [2,2,2,3].
Common mistake / implementation note
Save the old label before the scan; reading id[p] after it changes can relabel the wrong entries.
Save the old label before the scan; reading id[p] after it changes can relabel the wrong entries.
Original course code
Source: code/QuickFindUF.java. Original logic, comments, variable names and attribution are retained.
Download QuickFindUF.javaQuickFindUF.javaJAVA
/****************************************************************************** * Compilation: javac QuickFindUF.java * Execution: java QuickFindUF < input.txt * Dependencies: StdIn.java StdOut.java * Data files: https://algs4.cs.princeton.edu/15uf/tinyUF.txt * https://algs4.cs.princeton.edu/15uf/mediumUF.txt * https://algs4.cs.princeton.edu/15uf/largeUF.txt * * Quick-find algorithm. * ******************************************************************************/ import java.util.Arrays;import java.io.*; public class QuickFindUF { private int[] id; // id[i] = component identifier of i private int count; // number of connect components /* * Initializes an empty union-find data structure with */ public QuickFindUF(int n) { count = n; id = new int[n]; for (int i = 0; i < n; i++) id[i] = i; } /* * Returns the number of sets. */ public int count() { return count; } /** * Returns the canonical element of the set containing element {@code p}. */ public int find(int p) { validate(p); return id[p]; } // validate that p is a valid index private void validate(int p) { int n = id.length; if (p < 0 || p >= n) { throw new IllegalArgumentException("index " + p + " is not between 0 and " + (n-1)); } } /** * Returns true if the two elements are in the same set. * * @param p one element * @param q the other element * @return {@code true} if {@code p} and {@code q} are in the same set; * {@code false} otherwise * @throws IllegalArgumentException unless * both {@code 0 <= p < n} and {@code 0 <= q < n} * @deprecated Replace with two calls to {@link #find(int)}. */ @Deprecated public boolean connected(int p, int q) { validate(p); validate(q); return id[p] == id[q]; } /** * Merges the set containing element {@code p} with the * the set containing element {@code q}. * * @param p one element * @param q the other element */ public void union(int p, int q) { validate(p); validate(q); int pID = id[p]; // needed for correctness int qID = id[q]; // to reduce the number of array accesses // p and q are already in the same component if (pID == qID) return; for (int i = 0; i < id.length; i++) if (id[i] == pID) id[i] = qID; count--; } /** * Reads an integer {@code n} and a sequence of pairs of integers * (between {@code 0} and {@code n-1}) from standard input, where each integer * in the pair represents some element; * if the elements are in different sets, merge the two sets * and print the pair to standard output. */ public static void main(String[] args) { int n = StdIn.readInt(); QuickFindUF uf = new QuickFindUF(n); while (!StdIn.isEmpty()) { int p = StdIn.readInt(); int q = StdIn.readInt(); if (uf.find(p) == uf.find(q)) continue; uf.union(p, q); StdOut.println(p + " " + q); } StdOut.println(uf.count() + " components"); } }