#ifndef UNIONFIND_H_ #define UNIONFIND_H_ #include <assert.

h> #define ROOT_OF_GROUP -1 // Exceptions: class UFException { public: /* :o) */ protected: UFException() {}; private: /* :+) */ }; // Exceptions used by UnionFind are below class IllegalInput: public UFException { public: IllegalInput():UFException() {}; }; class OutOfBound: public UFException { public: OutOfBound():UFException() {}; }; // End of exceptions /* Generic implementation of unionFind data structure. * The class T has to have operator= */ template<typename T> class UnionFind { private: unsigned int n; int* parent; int* size; T* data; void fixer (const unsigned int realParent, unsigned int start) { if (bound(realParent) || bound(start)) { throw OutOfBound(); } while (parent[start]!=ROOT_OF_GROUP) { int temp = parent[start]; parent[start] = realParent; start = temp; } }; bool bound (const unsigned int num) const { return (num >= n); } public: /* Inits the UnionFind. * O(n) when n is the number of elements in the structure. */ UnionFind(const unsigned int num, T* src):n(num) { if (n == 0) { throw IllegalInput();

} parent = new int[num]; size = new int[num]; data = new T[num]; for (unsigned int i = 0; i < n; i++) { parent[i] = ROOT_OF_GROUP; size[i] = 1; data[i] = src[i]; } }; /* Destroys the data. * O(n) when n is the number of elements in the structure. */ ~UnionFind() { delete[] parent; delete[] size; delete[] data; }; /* The function getGroup returns the name of the "parent" * of the group numbered i. * O(log* n) when n is the number of elements in the structure. */ const int getGroup(const unsigned int i) { if (bound(i)) { throw OutOfBound(); } int j = i; while (parent[j] != ROOT_OF_GROUP) { j = parent[j]; } // now i has the index of the parent of the entire tree // we need to fix all the rest of the tree, to point // to the actual parent: fixer(j, i); return j; }; /* The function unite will join the smaller between "from" and "to", * and will put the information of "to" (or it's parent) in * the union's data. * O(log* n) when n is the number of elements in the structure. */ void unite(const unsigned int from, const unsigned int to) { if (bound(from) || bound(to)) { throw OutOfBound(); } int pickUp = getGroup(to), fromParent = getGroup(from); // // // if The parent of "from" is in "fromParent", and the parent of "to" is in "pickUp". Now we'll connect the smaller group to the bigger one: (size[fromParent] < size[pickUp]) { // meaning from is the smaller group parent[fromParent] = pickUp; size[pickUp] += size[fromParent]; size[fromParent] = 0; // meaning pickUp is the smaller group, or equal.

} else {

// keep the wanted data in the group's parent: parent[pickUp] = fromParent; size[fromParent] += size[pickUp]; size[pickUp] = 0; } }; /* Retrieve the data of the group which i is a member of. * O(log* n) when n is the number of elements in the structure. */ T* getData(const unsigned int i) { int j = getGroup(i); // Throws exception as needed // now j has the index of the parent of the entire tree // we need to fix all the rest of the tree, to point // to the actual parent: return &data[j]; }; }; #endif /* UNIONFIND_H_ */ /*==================================EOF====================================*/