K：Union-Find（并查集）算法

相关API	说明
UF(int N)	以整数标识(0到N-1)初始化N个触点
void union(int p,int q)	在p和q之间添加一条连接，也就是连接p和q
int find(int p)	p(0到N-1)所在的分量的标识
boolean connected(int p,int q)	如果p和q存在同一个分量中则返回true
int count()	连通分量的数量

quick-find算法:

该算法所采用的思想是保证当且仅当id[p]等于id[q]时，p和q是连通的。换句话说，在同一个连通分量中的所有触点，其相应的id[]中的值必须全部相同。为了确保调用union(int p,int q)时保证这一点，我们首先检查它们是否已经在同一连通分量中，如果在同一个连通分量中，我们就不采取任何行动，否则，我们面对的情况是p所在的连通分量中的所有触点的id[]值均为同一个值，而q所在的连通分量中的所有触点均为另一个值。要将两个分量合二为一，我们必须将两个集合中所有的触点所对应的id[]元素的值变为同一个值。为此，我们需要遍历整个数组，将所有和id[p]相等的元素的值变为id[q]的值。我们也可以将所有和id[q]相等的元素的值变为id[p]值，两者皆可。

相关代码：

class Quick_Find extends UF

{

	public Quick_Find(int N)

	{

		super(N);

	}

	@Override

	public int find(int p)

	{

		return id[p];

	}

	@Override

	public void union(int p, int q)

	{

		//检查p和q相关的连通分量的标识

		int pID=find(p);

		int qID=find(q);

		//如果p和q已经在相同的分量之中，则不需要采取任何的行动

		if(pID==qID)

			return;

		//将p的分量重命名为q的分量的标识

		for(int i=0;i<id.length;i++)

		{

			if(id[i]==pID)

				id[i]=qID;

		}

		count--;

	}

}

分析:

从上面的代码可知，find()的操作速度显然是很快的，因为其只需要访问id[]数组一次,其时间复杂度为O(1)，而union算法的时间复杂度为O(N)。但quick-find算法无法处理大型问题，因为对于每一对输入union()都需要扫描整个id[]数组。为此，当使用quick-find算法来解决问题的时候，特别是最后只是得到一个连通分量的问题的时候，其时间复杂度为O(N^2)。

quick-union算法:

该算法的目的在于提高union算法的速度，其与quick-find算法是互补的。他们基于相同的数据结构——以触点为索引的id[] 数组。但其数组中相关的值的含义却并不相同，我们需要用它来定义更加复杂的结构。确切的说，每个触点所对应的id[]都是同一个分量中的另一个触点的名称(也可能是自己)我们将这种联系称之为链接。在实现find()方法时，我们从给定的触点开始，由它链接得到另一个触点，再由这个触点的链接到达第三个触点，如此继续跟随着链接直到到达一个根触点，即链接指向自己的触点，该触点的标号同时也是该分量的标识。当且仅当分别由两个触点开始的这个过程到达了同一个根触点时，它们存在于同一个连通分量中。

相关代码:

class Quick_Union extends UF

{

	public Quick_Union(int N)

	{

		super(N);

	}

	@Override

	public int find(int p)

	{

		//找出该连通分量的标识，即连接指向自身的节点的标号

		while(p!=id[p])

			p=id[p];

		return p;

	}

	@Override

	public void union(int p, int q)

	{

		int pRoot=find(p);

		int qRoot=find(q);

		if(pRoot==qRoot)

			return;

		id[pRoot]=qRoot;

		count--;

	}

}

其union过程如下示意图1.2所示:

由于每个触点初始化之前均指向自身，为此，当每次union操作时，均会消除掉一个指向自身的触点，使得其中一个触点指向另一个指向自身的触点。我们可以将每个指向自身的触点的分量看成是一个整体，通过归纳，可以得知，无论从该连通分量的哪个触点出发进行find()操作，沿着其相关的链接进行查找。到最后总是可以找到其指向自身的一个触点，即为根触点，也就是该连通分量的标记。

分析:

quick-union算法看起来比quick-find算法快很多，因为它并不需要为每对输入遍历整个数组。在最好的情况，find()只需要访问数组一次就能够得到一个触点所在的连通分量的标记符；而在最坏的情况下，需要O(N)次访问(由于在初始时，每个触点均指向自身，若从开始到结束，在每次union的时候，将多个触点的连通分量链接到只有一个触点的连通分量的时，会出现连通分量合并成为一条“链”的情况，如图1.3所示)。为此，当使用quick-union算法对问题进行处理并最终只得到一个连通分量的时候，时间复杂度在最坏情况下为O(N^2)。出现这一种情况的根本原因在于进行union处理的时候，每次都将深度较深的连通分量所表示的树，链接到深度较浅的连通分量所代表的树中。为此，提出了如下的“加权quick-union”算法

加权quick-union算法:

加权quick-union算法是在quick-union算法的基础上进行改进的。其在quick-union的基础上做出的改变的是，与其在union()中随意的将一棵树连接到另外的一棵树，不如记录每一棵树的大小并总是将较小的树连接到较大的树上。这项改动需要添加一个额外的数组和一些代码来记录数中的节点数。

相关代码:

class WeightQuick_Union extends UF

{

	private int[] sz;//(由触点索引的)各个根节点所对应的分量的大小

	public WeightQuick_Union(int N)

	{

		super(N);

		sz=new int[N];

		for(int i=0;i<N;i++)

		{

			sz[i]=1;

		}

	}

	@Override

	public int find(int p)

	{

		while(p!=id[p])

			p=id[p];

		return p;

	}

	@Override

	public void union(int p, int q)

	{

		int i=find(p);

		int j=find(q);

		if(i==j)

			return;

		//将小树的根节点连接到大数的根节点

		if(sz[i]<sz[j])

		{

			id[i]=j;

			sz[j]+=sz[i];

		}

		else

		{

			id[j]=i;

			sz[i]+=sz[j];

		}

		count--;

	}

}

分析:

加权quick-union算法能够保证对数级别的性能。因为对于N个触点，加权quick-union算法构造的森林中的任意节点的深度最多为lgN。其证明过程如下:

证明:

可以通过归纳法证明一个更强的命题，即森林中大小为k的树的高度最多为lgk。在原始情况下，当k等于1时树的高度为0.根据归纳法，我们假设大小为i的树的高度最多为lgi，其中i < k。设i <= j且i+j=k，当我们将大小为i和大小为j的树归并时，小树中的所有节点的深度都增加了1，但它们现在所在的树的大小为i+j=k，而1+lgi=lg(i+i)<=lg(i+j)=lgk,性质成立。

路径压缩的quick-union算法:

虽然，加权quick-union算法能够保证在lgN的时间复杂度内解决问题，但是，仍然存在着一种比加权quick-union算法时间复杂度更低的算法，那就是使用路径压缩的quick-union算法。理想情况下，我们希望每个触点都直接的连接到其根节点上，但我们又不想像quick-find算法那样通过修改大量的连接而达到目的。于是，出现了一种接近这种理想状态的方法，那就是在检查触点的同时，把他直接连接到根节点上。该方法只需要在find(int p)中为其添加上一个循环，将在路径上遇到的所有节点都直接链接到其根节点上，这样我们所得到的结果是几乎完全扁平化的树。

相关代码:

class PathCompressWeightQuick_Union extends UF

{

	private int[] sz;//(由触点索引的)各个根节点所对应的分量的大小

	public PathCompressWeightQuick_Union(int N)

	{

		super(N);

		sz=new int[N];

		for(int i=0;i<N;i++)

		{

			sz[i]=1;

		}

	}

	@Override

	public int find(int p)

	{

		int temp=p;

		//运行结束后，p节点存储的为其根节点

		while(p!=id[p])

			p=id[p];

		while(temp!=p)

		{

			//用于记录当前节点p的父节点的编号

			int parent=id[temp];

			//将当前节点直接指向其根节点

			id[temp]=p;

			temp=parent;

		}

		return p;

	}

	@Override

	public void union(int p, int q)

	{

		int i=find(p);

		int j=find(q);

		if(i==j)

			return;

		//将小树的根节点连接到大数的根节点

		if(sz[i]<sz[j])

		{

			id[i]=j;

			sz[j]+=sz[i];

		}

		else

		{

			id[j]=i;

			sz[i]+=sz[j];

		}

		count--;

	}

}

分析:

使用路径压缩的加权quick-union算法，其均摊后的成本非常非常的接近但仍没能达到常数级别(O(1))。

并查集的使用场景举例：

在学到一个知识点的时候，我们可能会常常思考一个问题，那就是它有什么用？并查集也不例外，为了说明并查集的相关作用。此处，举了一些简单的例子，用以说明并查集的使用场景及其相关的作用，在举例的时候，使用整数来表示问题中的集合的每个单位。

网络: 输入的整数表示的是大型计算机网络中的计算机，而整数对则表示网络中的连接。使用并查集能够帮助我们判定在两台计算机P和q之间是否需要架设一条新的连接才能够进行通信，或者是我们可以通过已有的连接在两者之间建立通信线路；或者这些整数表示的可能是电子电路中的触点，而整数对表示的是连接触点之间电路；或者这些整数表示的可能是社交网络中的人，而整数对表示的是朋友关系，使用并查集，我们可以知道社交网络上的任意两个人之间，是否可以通过已知的连接发生联系。
变量名等价性: 某些编程环境允许声明两个等价的变量名(指向同一个对象的多个引用)。在一系列这样的声明之后，系统需要判断两个给定的变量名是否等价。这种较早出现的应用(如FORTRAN语言)推动了并查集相关的算法的发展。
数学集合: 在更高的抽象层次上，可以将输入的所有整数看做属于不同的数学集合。在处理一个整数对P和q时，我们是在判断它们是否属于相同的集合。如果不是，我们会将p所属的集合和q所属的集合归并到同一个集合中。该方式也是个人认为的，用于思考一个问题是否可以通过使用并查集来解决的最后的方式，先把问题进行抽象化，当问题抽象化成判断两个集合是否同属于一个集合的问题的时候，可以采用并查集来进行解决。

回到目录|·(工)·）

相关资料:《算法》第四版