并查集

并查集（Union Find），又称不相交集合（Disjiont Set），它应用于N个元素的集合求并与查询问题，在该应用场景中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。面对极大数据量时，并查集是解决该种问题的很优秀的。

简单实现：

#include<vector>

class DisjoinSet{
public:
	DisjoinSet(int n)//设置表示集合数组，初始时每个元素构成一个单元素的几个，编号为i的属于集合i
	{
		for(int i = 0; i < n; ++i)
			id.push_back(i);
	}

	int find(int p)
	{//查询p属于哪个集合
		return id[p];
	}

	void  union_(int p, int q)
	{
		int pid = find(p);
		int qid = find(q);
		if(pid == qid)
			return;
		for(int i = 0; i < id.size(); ++i)
		{
			if(id[i] == pid)
				id[i] = qid;//将所有属于pid集合的改为qid
		}
	}

	void print_set()
	{
		printf("元素： ");
		for(int i = 0; i < id.size(); ++i)
			printf("%d ", i);
		printf("\n");
		printf("集合： ");
		for(int i = 0; i < id.size(); ++i)
			printf("%d ", id[i]);
		printf("\n");
	}
private:
	std::vector<int> id;
};

#include<iostream>
#include"UnionSet.h"

using namespace std;

int main()
{
	DisjoinSet disjoint_set(8);
	disjoint_set.print_set();
	printf("Union(0,5)\n");
	disjoint_set.union_(0, 5);
	disjoint_set.print_set();
	printf("Find(0) = %d, Find(5) = %d\n", disjoint_set.find(0), disjoint_set.find(5));
	printf("Find(2) = %d, Find(5) = %d\n", disjoint_set.find(2), disjoint_set.find(5));
	disjoint_set.union_(2, 4);
	disjoint_set.print_set();
	disjoint_set.union_(0, 4);
	disjoint_set.print_set();
	printf("Find(2) = %d, Find(5) = %d\n", disjoint_set.find(2), disjoint_set.find(5));

	return 0;
}

森林实现：

使用森林存储集合之间的关系，属于同一集合的不同元素，都有一个相同的根结点，代表着这个集合。

当进行查找某元素属于哪个集合时，即遍历该元素到根结点，返回根结点所代表的的集合；在遍历过程中使用路径压缩的优化算法，使整体树的形状更加扁平，从而优化查询的时间复杂度

当进行合并时，即将两棵子树合为一棵树，将一棵子树的根结点指向另一棵子树的根结点；在合并时可按子树的大小，将规模较小的子树合并到规模较大的子树上，从而使树规模更加平衡，从而优化未来查询的时间复杂度

查找算法：

在查找时，普通的查找即通过id数组遍历至根结点：

当p与当前集合id[p]不同时（直到p与id[p]相同时跳出循环），进行循环：p = id[p] 。返回p的值

在查找时增加路径压缩的优化：

当p与当前集合id[p]不同时，（直到p与id[p]相同时跳出循环），进行循环：

    将p的父节点id[p]更新为id[p]的父节点id[ id[p] ]

    p = id[p]

返回p的值

合并算法：

当进行集合的合并时，将两棵子树合为一棵树，将一棵子树的根结点指向另一棵子树的根结点；

在合并时可按子树的大小，将规模较小的子树合并到规模较大的子树上，从而使树更加平衡

合并p所在的集合与q所在的集合：

    查找p所在集合的根，i = find(p);

    查找q所在集合的根，j = find(q);

    如果i和j相同，则直接返回；

    如果i所在子树规模小于j所在子树规模：

            将i的根指向j;

            j的规模增加i子树的规模

    否则：          

            将j的根指向i;

           i的规模增加j子树的规模

子树个数减1。

相比上面有一些修改

#include<vector>

class DisjoinSet{
public:
	DisjoinSet(int n)//设置表示集合数组，初始时每个元素构成一个单元素的几个，编号为i的属于集合i
	{
		for(int i = 0; i < n; ++i)
		{
			id.push_back(i);
			_size.push_back(1);
		}
		count = n;
	}

	//int find(int p)
	//{//查询p属于哪个集合
	//	return id[p];
	//}
	//森林实现的find
	int find(int p)
	{
		while(p != id[p])
		{
			id[p] = id[id[p]];
			p = id[p];
		}
		return p;
	}

	//void  union_(int p, int q)
	//{
	//	int pid = find(p);
	//	int qid = find(q);
	//	if(pid == qid)
	//		return;
	//	for(int i = 0; i < id.size(); ++i)
	//	{
	//		if(id[i] == pid)
	//			id[i] = qid;//将所有属于pid集合的改为qid
	//	}
	//}
	//森林实现的合并
	void union_(int p,int q)
	{
		int i = find(p);
		int j = find(q);
		if(i == j)
			return;

		if(_size[i] < _size[j])
		{
			id[i] = j;
			_size[j] +=  _size[i];
		}
		else{
			id[j] = i;
			_size[i] += _size[j];
		}
		count--;
	}

	void print_set()
	{
		printf("元素： ");
		for(int i = 0; i < id.size(); ++i)
			printf("%d ", i);
		printf("\n");
		printf("集合： ");
		for(int i = 0; i < id.size(); ++i)
			printf("%d ", id[i]);
		printf("\n");
	}
private:
	std::vector<int> id;
	//森林实现增加的：
	std::vector<int> _size;
	int count;
};