disjoint set (union-find set) (并查集)

 ref:http://en.literateprograms.org/Disjoint_set_data_structure_(C)
The three main operations in disjoint set are:
MakeSet: Create a new partition containing a single given element.
Find: Figure out which partition a given element is in.
Union: Merge two partitions into a single partition.

The most efficient known and most commonly used is disjoint set forests
with path compression and the union rank heuristic


#include<iostream>


#include <cstdlib>


#include <cassert>


using namespace std;


//forest node




typedef struct forest_node_t ...{


    void* value;


    struct forest_node_t* parent;


    int rank;


} forest_node;


forest_node* MakeSet(void* value);


forest_node* Find(forest_node* node);


void Union(forest_node* node1, forest_node* node2);




//find operation




forest_node* Find(forest_node* node) ...{


    forest_node* temp;




    /**//* Find the root */


    forest_node* root = node;




    while (root->parent != NULL) ...{


        root = root->parent;


    }




    /**//* Update the parent pointers */




    while (node->parent != NULL) ...{


        temp = node->parent;


        node->parent = temp;


        node = temp;


    }


    return root;


}




//union operation




/**//* Given the root elements of two trees, merge the trees into one tree */




/**//*


If rank(s) ≠ rank(t), then rank(Union(s,t)) is the larger of rank(s) and rank(t),


we attach the tree with smaller rank to the root of the tree with larger rank. 


If rank(s) = rank(t), then rank(Union(s,t)) = rank(s) + 1 = rank(t) + 1. 


*/




void Union(forest_node* node1, forest_node* node2) ...{




    if (node1->rank > node2->rank) ...{


        node2->parent = node1;




    } else if (node2->rank > node1->rank) ...{


        node1->parent = node2;




    } else ...{ /**//* they are equal */


        node2->parent = node1;


        node1->rank++;


    }


}




//Make-Set operation




forest_node* MakeSet(void* value) ...{


    forest_node* node = (forest_node*)malloc(sizeof(forest_node));


    node->value = value;


    node->parent = NULL;




    /**//*MakeSet always produces a tree of rank 0: */


    node->rank = 0;


    return node;


}






int main() ...{


    int i1=1, i2=2, i3=3;


    forest_node *s1=MakeSet(&i1), *s2=MakeSet(&i2), *s3=MakeSet(&i3);


    assert(Find(s1) == s1);


    Union(s1, s2);


    assert(Find(s1) == Find(s2));


    assert(Find(s1) != Find(s3));


    Union(s2, s3);


    assert(Find(s1) == Find(s2) &&


           Find(s1) == Find(s3));


    return 0;


}