图论之并查集二：

在 图论之并查集一 这篇文章里面，我们大概讲解了什么是并查集以及并查集的应用；而在这篇文章中，我们主要讲解并查集代码的相关优化。

这里重新贴上并查集的完整代码：

int[] parent;
 
/**
 * 1. 初始化
 */
public void init(int n){
    parent = new int[n];
    for (int i = 0; i < n; i++) {
        parent[i] = i;
    }
}
 
/**
 * 2. 查
 */
public int find(int x) {
    if (parent[x] == x) return x;
    int parentX = parent[x];
    return find(parentX);
}
 
 
/**
 * 3. 合并
 * @param x 元素1
 * @param y 元素2
 * @return false：表示两元素已经在同一个集合，不用合并    true：合并成功
 */
public boolean merge(int x,int y) {
    // 1. 找父元素
    int parentX = find(x);
    int parentY = find(y);
    // 若两个元素的祖先相同，说明已经在同一个集合了
    if (parentX == parentY) return false;
    // 2. 合并
    // 这里两种写法，哪一种都可以
    parent[parentX] = parentY;
    // parent[parentY] = parentX;
    return true;
}

很多童鞋看完代码之后，感觉并没有什么缺陷，我们画一画图就知道了。

一、缺陷提出

现有两个元素如下：

 按照我们的代码逻辑，将它们合并之后：

再来一个元素3： 

 

 合并之后：

 可以发现，随着元素的个数越来越多，链子的长度越来越长，并查集的使用越来越不方便。因此，我们必须采取一些措施，来进一步优化并查集。

二、路径压缩 

我们都知道，并查集的使用有三个过程：

1. 初始化
2. 查找
3. 合并

并查集的每一次查找，都是找到某一个元素的根元素即为结束。那么，我们不妨将根元素设置为其下所有元素的父元素。这样一来，我们在查找父元素时就不用一层一层往上追溯，而这就是路径压缩的原理。

 这一步只需在我们的查找代码中，稍作改变即可实现。

public int find(int x) {
    if (x == parent[x]) return x;  // 父节点就是本身，直接返回
    int root = find(parent[x]);
    parent[x] = root;
    return root;  // 将root节点当做其所有子节点的直接父节点，方便查询
}

画个图来对比一下，压缩前后我们查找父元素的层数：

 

压缩前： 

parent =  [1, 2, 3, 4, 5, 5]

压缩后：

parent = [5, 5, 5, 5, 5, 5]

对比前后的parent数组，压缩后，我们能更快地查找元素的根节点。

三、秩

上面的例子中，我们都只是将一个单独的节点合并到一个复杂的节点树上面。但在实际情况中，我们遇到的节点树，远比举例的还要复杂。

举个栗子：

 我们怎么去合并这两棵节点树？是将左边的树并到右边呢？还是将右边的树并到左边呢？

这里就要引出秩的概念：秩，我们可以简单的理解成树的深度。

我们的每一次合并，都可能会造成树的深度加大，进一步导致我们查找的速度变慢。树的深度越低，我们查找元素的速度就会更快。这样一来，我们合并的优化思路就有了：将树深度较低的，合并到树深度较大的，尽可能避免加大新树的深度。

3.1 代码

int[] parent;
int[] rank;
/**
 * 1. 初始化
 */
public void init(int n){
    parent = new int[n];
    rank = new int[n];
    for (int i = 0; i < n; i++) {
        parent[i] = i;
        rank[i] = 1; // 初始化所有树的深度都为1
    }
}

public void merge(int x,int y) {
    int parentX = find(x);
    int parentY = find(y);
    if (rank[x] <= rank[y]) {
        parent[parentX] = parentY;
    }else{
        parent[parentY] = parentX;
    }
    if (rank[parentX] == rank[parentY] && parentX != parentY) rank[parentY]++;
}

四、完整的代码

int[] parent;
int[] rank;
 
/**
 * 1. 初始化
 */
public void init(int n){
    parent = new int[n];
    rank = new int[n];
    for (int i = 0; i < n; i++) {
        parent[i] = i;
        rank[i] = 1; // 初始化所有树的深度都为1
    }
}
 
/**
 * 2. 查
 */
public int find(int x) {
    if (x == parent[x]) return x;  // 父节点就是本身，直接返回
    int root = find(parent[x]);
    parent[x] = root;
    return root;  // 将root节点当做其所有子节点的直接父节点，方便查询
}
 
 
/**
 * 3. 合并
 * @param x 元素1
 * @param y 元素2
 */
public void merge(int x,int y) {
    int parentX = find(x);
    int parentY = find(y);
    if (rank[x] <= rank[y]) {
        parent[parentX] = parentY;
    }else{
        parent[parentY] = parentX;
    }
    // 若两棵树的深度相同，合并之后，新树的深度加1
    if (rank[parentX] == rank[parentY] && parentX != parentY) rank[parentY]++;
}

五、测试代码

这里建议大家自己手动debug一下代码，观察parent数组的变化，彻底弄清楚路径压缩！！！

public class Test {

    int[] parent;

    public void init(int n) {
         parent = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }

    public int find(int x) {
        if (x == parent[x]) return x;  // 父节点就是本身，直接返回
        int root = find(parent[x]);
        parent[x] = root;
        return parent[x];  // 将root节点当做其所有子节点的直接父节点，方便查询
    }


    public void merge(int x,int y) {
        int parentX = find(x);
        int parentY = find(y);
        parent[parentX] = parentY;  // 直接将Y的根节点设置为  X的根节点的根节点
    }

    public static void main(String[] args) {
        Test t = new Test();
        t.init(6);
        t.merge(0,1);
        t.merge(0,2);
        t.merge(0,3);
        t.merge(0,4);
        t.merge(0,5);
        System.out.println(Arrays.toString(t.parent)); // [4, 2, 3, 4, 5, 5]
        t.find(1);
        System.out.println(Arrays.toString(t.parent)); // [4, 5, 5, 5, 5, 5]
        t.find(0);
        System.out.println(Arrays.toString(t.parent)); // [5, 5, 5, 5, 5, 5]
    }

}

感谢大家的耐心观看，如果觉得这篇文章对你有帮助的话，帮忙转发点赞收藏一下吧！！！