Disjoint Sets

April 2, 2010

Disjoint sets are a data structure that supports grouping, or partitioning, n distinct elements into a collection of sets, each containing a distinct subset of the elements. The operations supported by the data structure are find, which determines to which subset a particular element belongs, and union, when merges two subsets into one.

It is straight forward to implement disjoint sets using linked lists. The problem is that such a representation can have quadratic performance in the worst case, and the worst case, or something close to it, occurs reasonably often.

Thus, most algorithms textbooks describe a data structure called a disjoint-set forest. Each subset is represented by a tree, with each node containing a pointer to its parent; these are generalized trees, not binary trees, with potentially many children at each node. The make-set function returns a singleton tree, find chases parent pointers to the root of the tree, and union makes the root of one of the trees point to the root of the other in its parent. Two heuristics are common; union joins the tree with smaller rank (the upper bound on the depth of the tree) as a sub-tree to the tree with greater rank, and path compression replaces the parent pointer of each node with a pointer to the root of the tree instead of a pointer to the parent.

Your task is to implement a library that provides the make-set, find and union operations for disjoint sets, using the disjoint-set forest data structure described above. When you are finished, you are welcome to read or run a suggested solution, or to post your own solution or discuss the exercise in the comments below.


Pages: 1 2

3 Responses to “Disjoint Sets”

  1. Mike said

    I just created a class based on the python dict. I included path compression, but not the rank heuristics.

    class DisjointSet(dict):
        def add(self, item):
            self[item] = item
        def find(self, item):
            parent = self[item]
            while self[parent] != parent:
                parent = self[parent]
            self[item] = parent
            return parent
        def union(self, item1, item2):
            self[item2] = self[item1]
  2. […] studied disjoint sets in the previous exercise. In today’s exercise we use disjoint sets to implement Kruskal’s algorithm to find the minimum […]

  3. kaavannan said

    this method would help……

    int detectAndRemoveLoop(struct node *list)
    struct node *slow_p = list, *fast_p = list;

    while (slow_p && fast_p && fast_p->next)
    slow_p = slow_p->next;
    fast_p = fast_p->next->next;

    /* If slow_p and fast_p meet at some point then there
    is a loop */
    if (slow_p == fast_p)
    removeLoop(slow_p, list);

    /* Return 1 to indicate that loop is found */
    return 1;

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: