Union_Find

Union_Find:

1. 特殊的樹形結構

2. 解決聯通問題（e.g. 1.網絡聯通2.集合）

       只需簡單回答相關問題；

4. 兩個動作,一個判断

      Union（p , q）;
      Find ( p );
      Is _ connected( p , q );

5. 基本數據表示

    Quick_find數組 id [ ] /*組號*/;
		查找快
 	Quick_union數組 parent[ ]/*樹根*/
		性能好於quick_fin

6.優化

　	基於rank的優化(較優)
		Rank[i] 表示根節點為I 的數的高度
	基於size的優化
		Size[i] 表示根節點為i的數有多少個節點
		将元素个数少的集合合并到元素个数多的集合上
	Path compression(路径压缩)
		基於find  時間複雜度幾乎==O（ 1 ）

８.代码（初版）

基于quick_find数组

class UnionFind1
	{
	private:
		int* id; // 我们的第一版Union-Find本质就是一个数组
		int count = 0; // 数据个数	
	public:
		// 构造函数
		UnionFind1(int p) {
			id = new int[p];
			count = p;
			for (int i = 0; i < count; i++) {
				id[i] = i;
			}
		}
		// 析构函数
		~UnionFind1() {
			delete[] id;
		};
		// 查找过程, 查找元素p所对应的集合编号
		int find(int p) {
			assert(p >= 0 && p < count);
			return id[p];
		}
		// 查看元素p和元素q是否所属一个集合
	   // O(1)复杂度
		bool isConnected(int p, int q) {
			assert((p > 0 && p < count) || (q > 0 && q < count));
			return id[p] == id[q];
		}
		// 合并元素p和元素q所属的集合
		// O(n) 复杂度
		void unionElem(int p, int q) {
			int id_p = id[p];
			int id_q = id[q];
			if (id_p == id_q) {
				return;
			}
			else { // 合并过程需要遍历一遍所有元素, 将两个元素的所属集合编号合并
				for (int i = 0; i < count; i++) {
					if (id[i] == id_q) {
						id[i] = id_p;
					}
				}
			}
		}

基于Union_find数组

class UnionFind2
	{
	private:
			// 我们的第二版Union-Find, 使用一个数组构建一棵指向父节点的树
			// parent[i]表示第i个元素所指向的父节点
		int* parent;
		int  count = 0;
	public:
		// 构造函数
		UnionFind2(int count) {
			this->count = count;
			parent = new int[count];
			// 初始化, 每一个parent[i]指向自己, 表示每一个元素自己自成一个集合
			for (int i = 0; i < count; i++) {
				parent[i] = i;
			}
		}
		~UnionFind2() {
			delete[] parent;
		}
		// 查找过程, 查找元素p所对应的集合编号
	  // O(h)复杂度, h为树的高度
		int find(int p) {
			assert(p >= 0 && p < count);
			// 不断去查询自己的父亲节点, 直到到达根节点
			// 根节点的特点: parent[p] == p
			while (p != parent[p]) {
				p = parent[p];
			}
			return p;
		}
		// 查看元素p和元素q是否所属一个集合
		// O(h)复杂度, h为树的高度
		bool isConnected(int p, int q) {
			return find(p) == find(q);
		}
		// 合并元素p和元素q所属的集合
	    // O(h)复杂度, h为树的高度
		void unionElements(int p, int q) {
			int p_root =find(p);
			int q_root =find(q);

			if (p_root == q_root) {
				return;
			}
			else {
				parent[q_root] = p_root;
			}
		}
	};

８.代码（基于union的优化)

在unionElement操纵时

8.1(基于size的优化)

---

看谁的元素多,元素少的就接到元素多的集合下

class UnionFind3
{
private:
	int* parent;
	int* sz;
	int count;
public:
	UnionFind3(int p) {
		count = p;
		parent = new int[count];
		sz = new int[count];
		for (int i = 0; i < count; i++) {
			parent[i] = i;
			sz[i] = 1;
		}
	}
	~UnionFind3() {
		delete[] parent;
		delete[] sz;
	}
	int find(int p) {
		assert(p >= 0 && p < count);
		while (p != parent[p]) {
			p = parent[p];
		}
		return p;
	}
	bool isConnected(int p, int q) {
		return find(p) == find(q);
	}
	void unionElem(int p, int q) {
		int p_root = find(p);
		int q_root = find(q);

		if (p_root == q_root) {
			return;
		}
		// 根据两个元素所在树的元素个数不同判断合并方向
	    // 将元素个数少的集合合并到元素个数多的集合上
		if (sz[p_root] >= sz[q_root]) {
			parent[q_root] = parent[p_root];
			sz[p_root] += sz[q_root];
		}
		else {
			parent[p_root] = parent[q_root];
			sz[q_root] += sz[p_root];
		}
	}
};

8.2 (基于rank的优化)

看树的层数来决定谁接到谁的下面

class UnionFind4
	{
	private:
		int* parent;
		int* rank;//樹的層數
		int count;
	public:
		UnionFind4(int count) {
			parent = new int[count];
			rank = new int[count];
			this->count = count;

			for (int i = 0; i < count; i++) {
				parent[i] = i;
				rank[i] = 1;
			}
		}
		~UnionFind4() {
			delete[] parent;
			delete[] rank;
		}
		int find(int p) {
			assert(p >= 0 && p < count);
			// 不断去查询自己的父亲节点, 直到到达根节点
		   // 根节点的特点: parent[p] == p
			while (p != parent[p]) {
				p = parent[p];
			}

			return p;
		}
		// 查看元素p和元素q是否所属一个集合
	    // O(h)复杂度, h为树的高度
		bool isConnected(int p, int q) {
			return find(p) == find(q);
		}
		// 合并元素p和元素q所属的集合
	    // O(h)复杂度, h为树的高度
		void UnionElem(int p, int q) {
			int p_root = find(p);
			int q_root = find(q);

			if (p_root == q_root) {
				return;
			}
			// 根据两个元素所在树的元素个数不同判断合并方向
			// 将元素个数少的集合合并到元素个数多的集合上
			if (rank[p_root] > rank[q_root]) {
				parent[q_root] = p_root;
			}
			else if (rank[q_root] > rank[p_root]) {
				parent[p_root] = q_root;
			}
			else if (rank[p_root] == rank[q_root]) {
				parent[p_root] = q_root;
				rank[q_root] += 1;// 此时, 维护rank的值
			}
		}
	};

9 基于find的优化

在find操作时降低树的层数

	class UnionFind5
	{
	private:
		int* parent;
		int* rank;//樹的層數
		int count;
	public:
		UnionFind5(int count) {
			parent = new int[count];
			rank = new int[count];
			this->count = count;

			for (int i = 0; i < count; i++) {
				parent[i] = i;
				rank[i] = 1;
			}
		}
		~UnionFind5() {
			delete[] parent;
			delete[] rank;
		}
		int find(int p) {
			assert(p >= 0 && p < count);
			// 不断去查询自己的父亲节点, 直到到达根节点
		   // 根节点的特点: parent[p] == p
			while (p != parent[p]) {
				parent[p] = parent[parent[p]];
				p = parent[p];
			}
			// path compression 2, 递归算法
//            if( p != parent[p] )
//                parent[p] = find( parent[p] );
//            return parent[p];

			return p;
		}
		// 查看元素p和元素q是否所属一个集合
		// O(h)复杂度, h为树的高度
		bool isConnected(int p, int q) {
			return find(p) == find(q);
		}
		// 合并元素p和元素q所属的集合
		// O(h)复杂度, h为树的高度
		void UnionElem(int p, int q) {
			int p_root = find(p);
			int q_root = find(q);

			if (p_root == q_root) {
				return;
			}
			// 根据两个元素所在树的元素个数不同判断合并方向
			// 将元素个数少的集合合并到元素个数多的集合上
			if (rank[p_root] > rank[q_root]) {
				parent[q_root] = p_root;
			}
			else if (rank[q_root] > rank[p_root]) {
				parent[p_root] = q_root;
			}
			else if (rank[p_root] == rank[q_root]) {
				parent[p_root] = q_root;
				rank[q_root] += 1;// 此时, 我维护rank的值
			}
		}
	};