Union Find Data Structure

• Kruskal's presents us with a problem.
  • How do we implement Set Insertion, Find and Union quickly.
• To do this we will build a data structure with the following methods
  • MakeUnionFind(S) is a constructor.
    • The goal is to make this $O(|S|)$ for the given input set.
  • Find(s) $s \in S$.
    • Ideally this will be O(1), but we will settle for $O(\log |S|)$
  • Union(u,v) $u,v \in S$.
    • This will be $O(\log |S|)$
• A first approach
  • Maintain an array indexed by each element that contains the name of the set the element is in.
    • Assume $S = \{ 1, 2, 3, ..., n\}$
    • int component[i] = i can be constructed in O(n)
    • Find(s) {return component[s] is O(1)
    • Union(u,v)

      • for i = 1 to n 
           if component[i] == component[u]
              component[i] = component[v]
                        

      • This probably won't do
  • Can we optimize this?
    • vector<int> * component[i] = new vector<int>
    • Find(s) {return component[s]->first();}
    • Union(u,v)

      
       if (component[u]->size() > component[v]->size())
           swap (u,v)
       component[v]->append(component[u])
       tmp = component[u]
       for x in tmp 
           x = component[v]
       delete tmp
                  

    • This should be faster
    • Still can be O(n) for a single operation (when is it not faster)
  • But they claim that it is $O(|S| \log |S|)$ on average to merge everything.
    • This makes sense if we consider
    • The best case
      • Every time we add a single element to a larger set.
      • In this case, the merge will be O(1) (Line will only execute once per union)
      • So it is |S| to merge everything in this case.
    • The worst case
      • Every time we merge, we merge two sets of the same size.
      • If you think of this, it is just the merge portion of merge sort.
      • We will merge two single element sets $\frac{|S|}{2}$ times.
      • We will merge two two element sets $\frac{|S|}{4}$ times.
      • Assume $|S| = 2^k$, or $k=\log |S|$
      • Let T be the time to merge the entire set S, $T(|S|)= 2^0\frac{|S|}{2} + 2^1\frac{|S|}{4} + 2^2\frac{|S|}{8} + ... 2^{k-1} \frac{|S|}{2^k }$
      • $T(S) = \sum\limits_{i=o}^{k-1} 2^i\frac{|S|}{2^{i+1}} = \sum\limits_{i=0}^{\log |S| -1} \frac{|S|}{2}$
      • Which is $O(|S| \log |S|)$
    • So the worst case time for a union is $O(\log |S|)$
• An improved structure
  • At each element, maintain a pointer and a count
  • Merge(u,v)

     a = Find(u)
     b = Find(v)
     if b.size > a.size
       swap(a,b)
     b.parent = a
     a.size += b.size
            

  • Find(u)

     while u.parent != null
        u = u.parent
     return u
            

  • By the above, these are both $O(\log n)$ on average
  • And this takes much less space.
• A final improvement

   a = u
   while a.parent != null
      a = a.parent
   while u.parent != null
      u.parent = a
   return a