Worst-case Analysis of Set Union Algorithms

Reviewer: William Fennell Smyth

A typical set union problem is to determine a minimum-cost spanning tree (for example, spanning the nodes of a communications network). A Set Union Algorithm (SUA) consists of some sequence of the following fundamental operations: make set ( ): Create a new set with canonical element x; link (x,y): Combine two sets with canonical elements x, y into a single set whose canonical element is either x or y; find (x): Return the canonical element of the set containing the element x. It is supposed that the SUA includes altogether n make set operations and m find operations and that each set is structured as a tree with the canonical element as the root. An SUA is said to be separable if the canonical elements are initially assigned to separate sets. The authors first derive a new worst case lower bound :9I ( n + m &agr; ( m + n, n)) on the execution time for any separable SUA, where the function &agr; is an inverse of a modified Ackermann function (for practical purposes, 1 :9I &agr; :9I 4). The bulk of the paper is devoted to the consideration of various link and find strategies: Denote by size (x) the number of nodes in the tree rooted at x, and by rank (x) the length of the longest path from x to a leaf node. The link strategies considered are then based on the choice of the canonical element (root) for the combined set: naive linking: Choose either root ( x or y) arbitrarily; linking by size: Choose the root of largr size; linking by rank: Choose the root of larger rank. The authors show that if either linking by size or linking by rank is used, the worst case execution time of any separable SUA is &THgr;( n + m log n). The main find strategies considered are compression, splitting, and halving. These strategies may roughly be described as compactions; that is, for every node y on the path from x to the root which is not the root or a child of the root, find (x) resets the parent pointer (cp ( y) either to p( p( y)) or to some more distant ancestor. The authors then show inter alia that: (1)Separable SUAs which employ either linking by size or linking by rank together with any compaction strategy have a worst case execution time O( n + m&agr;( m + n, n:)) and are therefore asymptotically optimal; (2)for m :9I n, naive linking together with any compaction strategy yields asymptotic worst case execution time &THgr;( m log b n), where b = 1 + m/ n:; and (3)for m :9I n for linking by size or linking by rank, compaction strategies dominate other find strategies previously proposed in the literature ( reversal, collapsing, and splicing. This paper is based upon substantial previous work in the field by bother authors. By deriving new &THgr; bounds on worst case execution time, it provides important insights into efficient SUA strategies. The combinatorial arguments used to derive these bound depend heavily on the multiple partition technique due to Tarjan. These arguments are not for the faint of heart.