JAVA并查集的三种实现方式

最原始的实现方式

class UnionFind{
    private int[] parent;
   
    public UnionFind(int n){//初始化并查集，每个节点从属自己
    
        parent=new int[n+1];

        for(int i=1;i<=n;i++){
        
            parent[i]=i;
        }
    }

    public void union(int x,int y){//结合两个节点
    
        parent[find(x)] = find(y);
    }

    public int find(int x){//找到自己节点从属节点
    
        if(parent[x]==x){
        
            return x;
        }else{
        
            return find(parent[x]);
        }
    }
    
}

路径压缩并查集代码，该算法比原始算法的时间复杂度低。

 class UnionFind{
    private int[] parent;
   
    public UnionFind(int n){

         parent=new int[n+1];

        for(int i=1;i<=n;i++){
            parent[i]=i;
        }
    }

    public void union(int x,int y){
        parent[find(x)] = find(y);
    }

    public int find(int x){
        if(parent[x]==x){
            return x;
        }else{
            parent[x]=find(parent[x]);//A通过B找到C，则认为A直接属于C，树的深度降低
            return parent[x];
        }
    }
    
}

加入按秩合并的并查集，该算法通过牺牲空间复杂度，进一步降低时间复杂度。

class UnionFind{
    private int[] parent;
    private int[] rank;
   
    public UnionFind(int n){

         parent=new int[n+1];
         rank=new int[n+1];

        for(int i=1;i<=n;i++){
            parent[i]=i;
            rank[i]=1;//设置所有节点初始秩为1
        }
    }

    public void union(int x,int y){
    int a=find(x);
    int b=find(y);
    if(rank[a]<=rank[b]){//如果a的秩小于等于b的秩，则将a合并到b
        parent[a] = b;
        if(rank[a]==rank[b]){//如果a,b的秩相等，则需要将b的秩加一
       		 rank[b]++;
        }
    }else{
    	parent[b]=a;//如果b的秩小于a的秩，则将b合并到a
    }
    }

    public int find(int x){
        if(parent[x]==x){
            return x;
        }else{
            return find(parent[x]);
        }
    }
    
}

注意：按秩合并与路径压缩不能合并使用，如果二者合并使用则会影响到秩的准确性，但是如果一起使用将会将时间复杂度进一步降低到接近O(N)