Disjoint Sets Set a collection of distinguishable elements

Disjoint Sets Set = a collection of (distinguishable) elements n Two sets are disjoint if they have no common elements n Disjoint-set data structure: n – maintains a collection of disjoint sets – each set has a representative element – supported operations: • Make. Set(x) • Find(x) • Union(x, y) 1

Disjoint Sets n Used in applications requiring the partition of a set into equivalence classes. – Maze generation – Several graph algorithms • (e. g. Kruskal's algorithm for minimum spanning trees) – Compiler algorithms • Equivalence of finite automata 2

Disjoint Sets n Major operations: – Make. Set(x) • Given an object x, create a set out of it. The representative of the set is x – Find(x) • Given an object x, return the representative of the set containing x – Union(x) • Given elements x, y, merge the sets they belong to. • The original sets are destroyed. • The new set has a new representative 3

Disjoint Sets n In the discussion that follows: – n is the total number of elements (in all sets) – m is the total number of operations performed (a mix of Make. Set, Union, Find operations) • m is at least equal to n since there must be a Make. Set operation for each element. • The maximum number of Union operations that may be performed is n-1. – We will perform amortized analysis. 4

Disjoint Sets n Implementation #1: Using linked lists – The head of the list is also the representative – Each node contains • an element • a pointer to the next node • a pointer to the representative – Why? Because this will speed up the Find operation 5

Disjoint Sets n Implementation #1: Using linked lists – Make. Set(x) • Create a list with one node, x • Time for one operation: O(1) – Find(x) • Assuming we already have a pointer to x (*), just return the pointer to the representative • Time for one operation: O(1) (*) usually, we have a vector of pointers to the individual nodes 6

Disjoint Sets n Implementation #1: Using linked lists – Union(x, y) • • Perform Find(x) to find x's representative, rx Perform Find(y) to find y's representative, ry Append ry's list to the end of rx's list rx becomes the representative of the new set. – The elements that used to be in ry's list should have their pointers to the representative updated. » Idea #1: Do a lazy update: set ry's pointer to rx and leave the rest the way they are. This will make Union faster but will slow down the Find operation. » Idea #2: Update all applicable pointers. This will maintain the constant Find() time. 7

Disjoint Sets n Implementation #1: Using linked lists – Union(x, y) • A sequence of m operations may take O(m+n 2) time – How? Given elements 1, 2, 3, . . . , n, do Union(1, 2), Union(3, 1), Union(4, 1), etc. At step i, we attach a list of length i to a list of length 1, thus updating i pointers to the new representative. After n 1 unions, we'll have a single set and we will have performed O(n 2) pointer updates. • So let's be smart about it: – Keep track of the length of each list and always append the shorter list to the longer one. 8

Disjoint Sets n Implementation #1: Using linked lists – Union(x, y) • A sequence of m operations where all unions append the shorter list to the longer one takes O(m+nlgn) time • Why? Because with each union we attach a list of length i to a list of length at least i, thus doubling the length of the list. By the time we get a single set containing all elements, each element's pointer to the representative will have been updated lgn times, thus giving us a total of nlgn pointer updates. 9

Disjoint Sets n Implementation #2: Using arrays – Maintain an array of size n – Cell i of the array holds the representative of the set containing i. – Similar to lists, simpler to implement if we know the number of elements in advance. 10

Disjoint Sets n Implementation #3: Using trees – Each set is represented by a tree structure where every node has a pointer to its parent. • This tree is called an up-tree – The root is the representative of the set – The elements are not in any particular order. 11

Disjoint Sets n Implementation #3: Using trees – Make. Set(x) • Create a tree containing only the root, x • Time for one operation O(1) – Find(x) • Follow the parent pointers to the root. • Time for one operation: O(depth of node) – Could be up to O(n) 12

Disjoint Sets 12 5 8 3 9 1 2 13

Disjoint Sets n Implementation #3: Using trees – Union(x, y) • Perform Find(x) to locate the representative of x, sx • Perform Find(y) to locate the representative of y, sy • Make sy a child of sx – Danger: if we are not smart about it, our tree may end up looking like a list 1 1 + 1 2 2 + 1 + 3 2 4 2 3 3 4 14

Disjoint Sets n Implementation #3: Using trees – Union(x, y) • Always make the smaller tree a child of the larger tree. • How do we define "smaller"? – Heuristic #1: Union-by-weight » Smaller = fewer nodes » Store number of nodes at the representative » Add the two weights when performing a union – Heuristic #2: Union-by-height » Smaller = shorter » Store height at the representative » The height increases only when two trees of equal height are united. 15

Disjoint Sets n Implementation #3: Using trees – Union(x, y) • The height of a tree is at most logn+1 where n is the number of elements in the tree. • We can do better than that! • Optimizing the union through path compression. – Our goal is to minimize the height of the tree – Every time we perform a Find(z) operation, we make all nodes on the path from the root to z immediate children of the root. – When path compression is performed, a sequence of m operations takes O(mlgn). 16

Disjoint Sets n Implementation #3: Using trees – Union(x, y) • Path compression and union-by-weight can be performed at the same time. • Path compression and union-by-height- can be performed at the same time. – It's more complex since path compression changes the height of the tree. – We usually prefer to estimate the height instead of computing it exactly. We then talk about union-by-rank with path compression. • When we perform union-by-weight/height with path compression, a sequence of m operations is almost linear in m 17