[Java]Union-Find算法

union-find算法(并查集算法)

[Java]Union-Find算法_第1张图片

如上图所示就是一组简单的连通性问题
其中0与1是相连的,1与8是相连的,等等
该图一共具有四个等价分量,分别是(0,1,8)(2,3,4,9,10,11)(5,6,12,13)(7)
动态连通性:(即相连的两个节点分别具有的性质)
  1. 自反性,P与P是相连的
  2. 对称性,若P与Q相连,则Q与P也相连
  3. 传递形,P与W相连,W与Q相连,则P与Q也相连

union-find算法简化了对节点本身值的讨论,而更注重于节点之间的联通关系,初始状态下,每个节点在数组中的值都等于各自的索引值,在连接过程中,两个被连接的节点将被赋予相同值,这个值来自于连接的两个节点其中之一

例如:9与10连通,则9与10的值都变为9,后来,2与9连通,2,9,10三个的值均变为2
其本质就是将已经连通的节点归并到同一集合中,所以节点本身的值实际不在考虑范围内,也因此我们无法通过union-find算法求得某两点之间的路径,只能判断这两个点是否连通

union-find算法的API

public class UnionFind 操作
构造函数 UnionFind(int N) 以整数标识0~N-1,初始化N个触点
void union(int p,int q) 将p和q两个节点连接
int find(int p) 返回p在网络中的标识符(值,也就是对应集合)
boolean connected(int p,int q) 判断p和q两个节点是否相连
int count() 返回连通分量的数量

union-find算法实现

实现一:quick-find算法
这个算法保证了find方法的高效性,也就是我们前文提到过的忽略每个节点值的意义,一旦连接两个节点,就对两个节点所在的连通分量进行处理,使两个两桶分量的标识符相等(通过遍历整个数组实现)
这虽然保证了find的高效性(只需要遍历一次数组就能得到所在连通分量),但这使union方法无法处理大型数据,因为每连通一次都需要遍历整个数组
package cn.ywrby.UF;

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;

public class UnionFind {
	private int[] id; // 存放节点的数组
	private int count; // 分量数量
	// 初始化类

	public UnionFind(int N) {
		count = N; // 元素数量
		id = new int[N];
		for (int i = 0; i < N; i++) {
			id[i] = i;
		}
	}

	// 返回当前分量数量
	public int count() {
		return count;
	}

	// 判断两个节点是否连通
	public boolean connected(int p, int q) {
		return id[p] == id[q];
	}

	// 判断当前节点所处的分量
	public int find(int p) {
		return id[p];
	}

	// 对两个节点进行联通
	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;
			}
		}
		count--;
	}

	public static void main(String[] args) {
		int N = StdIn.readInt();
		UnionFind uf = new UnionFind(N);
		while (!StdIn.isEmpty()) {
			int p = StdIn.readInt();
			int q = StdIn.readInt();
			if (uf.connected(p, q))
				continue;
			uf.union(p, q);
			StdOut.println(p + " connected " + q);
		}
		StdOut.println(uf.count + "components");
		// TODO 自动生成的方法存根

	}

}
quick-find算法分析:
算法运行过程中,每次调用find算法对数组只进行一次遍历,当调用connected方法时如果两个节点没有连通,则进行的遍历次数在(N+3)~(2N+1)之间。(首先调用两次find,然后再for循环处进行N次遍历,最后如果条件成立id[i]=qID;处进行至少一次,至多N-1次遍历)
分析最坏情况,使用该算法并且最后只剩一个联通变量,则至少进行了N-1次连接操作,所以访问数组次数至少(N+1)*(N+3)~N^2次,该算法为平方级别

实现二:quick-union算法
这个算法实现了高效的union方法,它引用到了最基础的树的概念,通过保存上一个节点的索引,找到根节点,再通过比较根节点,判断两个节点是否同属于一个分量中。
package cn.ywrby.UnionFind;

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;



public class QuickUnion {
    private int[] id; // 存放节点的数组
    private int count; // 分量数量
    // 初始化类

    public QuickUnion(int N) {
        count = N; // 元素数量
        id = new int[N];
        for (int i = 0; i < N; i++) {
            id[i] = i;
        }
    }

    // 返回当前分量数量
    public int count() {
        return count;
    }

    // 判断两个节点是否连通
    public boolean connected(int p, int q) {
        return id[p] == id[q];
    }

    // 判断当前节点所处的分量
    public int find(int p) {
        while(id[p]!=p){
            p=id[p];
        }
        return p;
    }

    // 对两个节点进行联通
    public void union(int p, int q) {
        int pRoot=find(p);
        int qRoot=find(q);
        if(qRoot==pRoot){
            return;
        }
        id[qRoot]=pRoot;
        count--;
    }

    public static void main(String[] args) {
        int N = StdIn.readInt();
        QuickUnion uf = new QuickUnion(N);
        while (!StdIn.isEmpty()) {
            int p = StdIn.readInt();
            int q = StdIn.readInt();
            if (uf.connected(p, q))
                continue;
            uf.union(p, q);
            StdOut.println(p + " connected " + q);
        }
        StdOut.println(uf.count + "components");
        // TODO 自动生成的方法存根

    }

}
算法分析
quick-union算法可以看作是对quick-find算法的一次改良,它解决了union方法是平方级别的问题(在quick-union中一般情况下为线性的)。
find方法在最好情况下只需要遍历一次数组(即该节点为根节点时),最坏情况为2N+1次数组(当节点位于最尾端时,while循环遍历数组N+1次,赋值语句遍历数组N次)
同样的,quick-union在最坏情况下(只有一个连通分量时),也是N^2级别的

实现三:加权quick-union算法
quick-union算法出现的主要问题就是树的平衡性,由于没有控制树的生长方式,所以可能造成众多子树线性的连接在一起,增加find成本
通过简单的加权,我们可以控制树的生长,保证始终将小树连接到大树上
package cn.ywrby.UnionFind;

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;

public class WeightedQuickUnion
{

    private int[] id; // 存放节点的数组
    private int[] sz; //存放各个节点所在分量的根节点数目
    private int count; // 分量数量
    // 初始化类

    public WeightedQuickUnion(int N) {
        count = N; // 元素数量
        id = new int[N];
        for (int i = 0; i < N; i++) {
            id[i] = i;
        }
        sz=new int[N];
        for(int i=0;i<N;i++){
            sz[i]=1;  //初始化每个分量的数量
        }
    }

    // 返回当前分量数量
    public int count() {
        return count;
    }

    // 判断两个节点是否连通
    public boolean connected(int p, int q) {
        return id[p] == id[q];
    }

    // 判断当前节点所处的分量
    public int find(int p) {
        while(id[p]!=p){
            p=id[p];
        }
        return p;
    }

    // 对两个节点进行联通
    public void union(int p, int q) {
        int pRoot=find(p);
        int qRoot=find(q);
        if(qRoot==pRoot){
            return;
        }
        //比较节点对应分量的大小,再进行合并
        if(sz[pRoot]<sz[qRoot]){
            id[pRoot]=qRoot;
            sz[qRoot]+=sz[pRoot];  //修改该分量元素数目
        }
        else{
            id[qRoot]=pRoot;
            sz[pRoot]+=sz[qRoot];
        }
        count--;
    }

    public static void main(String[] args) {
        int N = StdIn.readInt();
        WeightedQuickUnion uf = new WeightedQuickUnion(N);
        while (!StdIn.isEmpty()) {
            int p = StdIn.readInt();
            int q = StdIn.readInt();
            if (uf.connected(p, q))
                continue;
            uf.union(p, q);
            StdOut.println(p + " connected " + q);
        }
        StdOut.println(uf.count + "components");

    }
}
算法分析:
根据算法特性不难发现,加权后形成的树最大深度不会超过lgN。所以find,union的成本增长数量级为lgN。这是目前为止最优的算法

三种算法运行过程中遍历数组次数比较

public class AnalysisChart {
    public static void main(String[] args) {
        int N = 5000;
        QuickUnion qu = new QuickUnion(N);
        VisualAccumulator accumulator=new VisualAccumulator(N,2*N+1);
        StopWatch watch=new StopWatch();
        for(int i=0;i<N;i++){
            Random r =new Random();
            int p=r.nextInt(N);
            int q=r.nextInt(N);
            if (qu.connected(p, q)) {continue;}
            qu.union(p, q);
            accumulator.addDataValue(qu.NUM);
            qu.NUM=0;
            StdOut.println(p+" connected "+q);

        }
        double time=watch.elapsedTime();
        StdOut.println(qu.count() + "components");
        StdOut.println("time = " + (time));
        
    }
}
quick-find算法

[Java]Union-Find算法_第2张图片

quick-uniob算法

[Java]Union-Find算法_第3张图片

加权的quick-union算法

[Java]Union-Find算法_第4张图片

你可能感兴趣的:(java,算法,数据结构)