并查集--Java实现

将展示三种不同的并查集实现，通过这样的演化过程来体会并查集的思想。
三种实现里，都用到了一个id数组，但是具体的含义略有不同。

quick-find

这种实现里，id数组长度为N，如果p和q是相连的，那么它们的id数组里的值相同，即id[p] == id[q]。

所以对于find函数，找到该元素的上级。

// 初始化
public QuickFindUF(int N) {id = new int[N];for(int i = 0; i < N; i++) {id[i] = i;}
}
public int find(int p) {return id[p];
}
// 将p和q放到同一个组件内：联合
public void union(int p, int q) {int pID = find(p);int qID = find(q);// 如果已经相同，表示已经在同一个组件，无需再联合if (pID == qID) return;for(int i = 0; i < id.length; i++) {if(id[i] == pID) id[i] = qID; // 将pID组件元素全都交给qID吧，这是任意的，可以反过来全部交给pID}
}

这种写法，查询p和q是否连通是很快的，是O(1)时间复杂度，而连接起来则是O(N)时间复杂度。这还是单次操作，也就是说，总体来看，Union的操作需要O(N^2)复杂度。

现在我们把注意力转向优化Union操作。

quick-union

这里的id数组是有额外含义的，id[i]的值是i元素的父亲。那么，按照这个逻辑推演，i元素的根就是id[id[...id[i]...]]，一直往前，直到该值不再变化为止。

所以，判断p和q是否在一个组件内，只需要各自找到自己的root值，判断它们的root值是否相等即可。

public int find(int p) {while(p != id[p]) p = id[p]; // 一路向上return p;
}
public void join(int p, int q) {int pRoot = find(p);int qRoot = find(q);if (pRoot == qRoot) return;id[pRoot] = id[qRoot]; // 直接将其中一个root值变成另外一个的小弟
}

weighted quick-union

在上面join时，只是随意将其中一个对象的根变成另一个的小弟，没有进行过滤，这样导致的结果是，树可能会很不平衡，从而在查找时耗时很长。

改进也很简单，跟踪一下树的尺寸，将小一点的树连接到大一点的树，即小一点的作为小弟即可。

public class WeightedQuickUnionUF {private int[] id;private int[] sz; // size of component for rootsprivate int count; // number of componentspublic WeightedQuickUnionUF(int N) {count = N; // 初始时有N个组件id = new int[N];sz = new int[N];  for(int i = 0; i < N; i++) {id[i] = i;sz[i] = 1;}}public int count() {return count;}public boolean connected(int p, int q) {return find(p) == find(q);}private int find(int p) {while(p != id[p]){p = id[p];}return p;}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--; // 执行一次union，才需要减一次}
}

到此为止，我们学习了三种方式，逐渐优化。但是还有进一步的可能，那就是路径压缩。

路径压缩非常简单，只需要额外的一行即可：

private int find(int p) {while(p != id[p]) {id[p] = id[id[p]];p = id[p];}
}

END.