• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

并查集(一)并查集的几种实现

开发技术 开发技术 33分钟前 1次浏览

概述

并查集是一种特别的数据结构,在解决连通行问题屡试不爽。以下代码均为java语言的实现

并查集的作用先总体说一下

  • 1、将两个元素联通起来(union)起来,形成一个通路
  • 2、检查任意两个元素是否是连通的
  • 3、连通后,如果把连通的一组数看成一组,那么还能记录一共有多少组数
  • 4、当然也还能求组员数最大、最小的组的数量【通过计数变形】

对外基础方法提供2个方法

  • public void join(int a, int b) 连通a节点和b节点
  • public boolean isJoined(int a, int b) 判断任意两个节点是否是连通的

内部需要一个辅助方法

来查询任意节点的根节点,本身你可以理解并查集是一颗树,但这颗是反向寻找,并不是像通常的树,自顶向下dfs的,而是一直向上找寻根节点

  • private int findP(int x) 查询x元素的根节点

快速查询版本

将连通节点的父节点都设置为相同节点(索引),查询的时候 f(x)=parent[x],但更新比较麻烦,每次更新需要遍历所有元素O(n)的复杂度,n是总的元素个数

/**
 * 并查集  快速查询
 */
public class UFQuickFind {

    int[] parent;

    public UFQuickFind(int size) {
        parent = new int[size];
        for (int i = 0; i < parent.length; i++) {
            parent[i] = i;
        }
    }


    private int findP(int x) {//查询操作,其实是查询  根节点
        if (x < 0 || x >= parent.length)
            return -1;  //或者直接抛出异常

        return parent[x];   //直接返回 parent就可以了,因为所有  连接 的节点parent值都相同
    }

    public void join(int a, int b) {
        int ap = findP(a);
        int bp = findP(b);
        if (ap != bp) {
            for (int i = 0; i < parent.length; i++) {
                if (parent[i] == ap)
                    parent[i] = bp; //修改成相同的 parent
            }
        }
    }

    public boolean isJoined(int a, int b) { //两个节点是否是  连接的
        return findP(a) == findP(b);
    }


}

快速合并版

合并的时候,a,b元素,直接让将a的父亲指向b的父亲。【通俗一点 a节点的父亲 认b节点的根节点做父亲了,最后a节点tm的就程b节点的根节点的孙子了】

/**
 * 快速合并
 */
public class UFQuickUnion {

    int[] parent;

    public UFQuickUnion(int size) {
        parent = new int[size];
        for (int i = 0; i < parent.length; i++) {
            parent[i] = i;
        }
    }

    private int findP(int x) {//查询操作,其实是查询  根节点
        if (x < 0 || x >= parent.length)
            return -1;  //或者直接抛出异常

        while (parent[x] != x)//一直搜索到根节点
            x = parent[x];

        return x;
    }

    public void join(int a, int b) {
        int ap = findP(a);
        int bp = findP(b);
        if (ap != bp) {
            parent[ap] = bp;//让其中一个节点的根节点 指向  另外一个节点的根节点
        }
    }

    public boolean isJoined(int a, int b) { //两个节点是否是  连接的
        return findP(a) == findP(b);
    }

}

基于每株节点数的合并

由于快速合并的过程,合并的过程是随机的,如果所有节点都合并到一起,那么最后这颗树可能变成一个链表【就是接龙,成为一条线】,通过节点数来改进,节点数少的接到节点数多的上面,这样肯定不会成一个链表

public class UFNumsUnion {


    int[] parent;
    int[] nums;//节点数

    public UFNumsUnion(int size) {
        parent = new int[size];
        nums = new int[size];
        for (int i = 0; i < parent.length; i++) {
            parent[i] = i;
            nums[i] = 1;
        }
    }

    private int findP(int x) {//查询操作,其实是查询  根节点
        if (x < 0 || x >= parent.length)
            return -1;  //或者直接抛出异常

        while (parent[x] != x)//一直搜索到根节点
            x = parent[x];

        return x;
    }

    public void join(int a, int b) {
        int ap = findP(a);
        int bp = findP(b);
        if (ap != bp) {
            //a节点多,就将 b节点往a节点上合并,这样的话可以减少树的高度
            if (nums[ap] > nums[bp]) {
                parent[bp] = ap;
                nums[ap] += nums[bp];    //根节点的节点数  增加了  被合并节点的节点数
            } else {
                parent[ap] = bp;
                nums[bp] += nums[ap];
            }
        }
    }


    public boolean isJoined(int a, int b) { //两个节点是否是  连接的
        return findP(a) == findP(b);
    }

}

基于层数的实现

【基于每株节点数的合并】虽然已经挺好的了,但偶尔也会不太合理的情况如下所示


   A:      o
        / |  
       o  o  o o        5个节点,两层
      
  
   B:    o
       / | 
      o  o              4个节点  3层
     /
    o 

上面这种情况按照基于节点数的合并,会得到一个4层的树(层的深度增加),而更合理的方式是让A接到B上,这样最后整体层数保持在3层。层数越小,那么findP方法就会变快,而合并也因为调用findP方法也会加快。

基于层数的实现,永远让层数矮的接到层数高的树上

public class UFRankUnion {

    int[] parent;
    int[] rank;//树的层数
    int plant;  //一共有多少株树

    public UFRankUnion(int size) {
        plant = size;
        parent = new int[size];
        rank = new int[size];
        for (int i = 0; i < parent.length; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }


    private int findP(int x) {//查询操作,其实是查询  根节点
        if (x < 0 || x >= parent.length)
            return -1;  //或者直接抛出异常

        while (parent[x] != x)//一直搜索到根节点
            x = parent[x];

        return x;
    }


    public void join(int a, int b) {
        int ap = findP(a);
        int bp = findP(b);
        if (ap != bp) {
            plant--;
            //a的层数越高,就将层数少的合并到层数高的上面
            if (rank[ap] > rank[bp])
                parent[bp] = ap;
            else if (rank[ap] < rank[bp]) {
                parent[ap] = bp;
            } else {
                //相同情况的话,随便就可以,但总体层高会增加1,画一个相同层的树合并一下就知道
                parent[ap] = bp;
                rank[bp]++;
            }
        }
    }

    public int getPlant() {
        return plant;
    }

    public boolean isJoined(int a, int b) { //两个节点是否是  连接的
        return findP(a) == findP(b);
    }


}

路径压缩

我们设想一下并查集的理想状态,所有树都是深度为1的树,这种理想状况的findP的时间复杂度为O(1),大大提高了查询性能,如下图所示

           o             o
        / |          / |  
       o  o  o o      o  o  o
       
     
       所有的树都是以这种方式去组合的

但是我们知道,如果A和B合并,层高是不是又变成2层了,如何才能让层高再次恢复到1层呢。这里路径压缩的一种方式是在查询的时候,将查询的节点不断往上提高,直接接到根节点上

      节点1  o         
           / |        
   节点2  o  o  o
         /
 节点3  o 节点1

查询节点3的时候,是不是让节点3接到 节点2的父节点上 parent[节点3]= parent[节点2]

public class UFRankUnionCompressPath {


    int[] parent;
    int[] rank;//树的层数
    int plant;  //一共有多少株树

    public UFRankUnionCompressPath(int size) {
        plant = size;
        parent = new int[size];
        rank = new int[size];
        for (int i = 0; i < parent.length; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

    private int findP(int x) {//查询操作,其实是查询  根节点
        if (x < 0 || x >= parent.length)
            return -1;  //或者直接抛出异常

        while (parent[x] != parent[parent[x]])
        //如果parent[x]==parent[parent[x]] 说明这颗树到了第二层,或者第一层
        //第一层 因为parent[x]=x所以有  parent[x]==parent[parent[x]]
        //第二层 因为第二层的parent是根节点 有: parent[x]= root  
        //所以有 parent[parent[x]]= parent[root]  而本身 parent[root]=root
        {
            // x = parent[x];  //
            parent[x] = parent[parent[x]]; //将下层节点往顶层提升,最终
        }
        return parent[x];
    }


    public void join(int a, int b) {
        int ap = findP(a);
        int bp = findP(b);
        if (ap != bp) {
            plant--;
            //a的层数越高,就将层数少的合并到层数高的上面
            if (rank[ap] > rank[bp])
                parent[bp] = ap;
            else if (rank[ap] < rank[bp]) {
                parent[ap] = bp;
            } else {
                //相同情况的话,随便就可以
                parent[ap] = bp;
                rank[bp]++;
            }
        }
    }

    public int getPlant() {
        return plant;
    }

    public boolean isJoined(int a, int b) { //两个节点是否是  连接的
        return findP(a) == findP(b);
    }
}

期待下一篇,并查集运用相关得算法题及题解


程序员灯塔
转载请注明原文链接:并查集(一)并查集的几种实现
喜欢 (0)