《算法4第一章》笔记（九）动态连通性(2) quick-union

问题描述：

动态连通性：输入为一列整数对，其中每个整数对都表示一个某种弄类型的对象，一堆整数p q可以被理解为“p和q是相连的”。当程序从输入中读取了整数对p q时，如果一直的所有整数对都不能说明p和q是相连的，那么则将这一对整数写入到输出中。

• p和q称为触点。
• p和q的通道称为分量。

quick-union算法比较quick-find算法，提高了union()方法的速度，它算是和quick-find算法师互补的。

quick-union源码：

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

public class UF {
    private int[] id;// 分量id(以触点作为索引)
    private int count;// 分量数量

    public UF(int N) {
        count = N;
        id = new int[N];
        // 初始化分量id
        for (int i = 0; i < N; i++) {
            id[i] = i;
        }
    }

    public int count() {
        return count;
    }

    public boolean connected(int p, int q) {
        return find(p) == find(q);
    }

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

    public void union(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);
        if (pRoot != qRoot) {
            return;
        }
        id[pRoot] = qRoot;
        count--;
    }

    public static void main(String[] args) {
        int N = StdIn.readInt();
        UF uf = new UF(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 + " " + q);
        }
        StdOut.println(uf.count + " components");
    }

}

程序输入取自tinyUF.text文件

10
4 3
3 8
6 5
9 4
2 1
8 9
5 0
7 2
6 1
1 0
6 7

程序入口

public static void main(String[] args) {
    int N = StdIn.readInt();// 读取触点数量
    UF uf = new UF(N);// 初始化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 + " " + q);// 打印链接
    }
    StdOut.println(uf.count + " components");
}

算法逻辑分析

public int find(int p) {
    // 找出分量的名称
    while (p != id[p]) {
        p = id[p];
    }
    return p;
}

public void union(int p, int q) {
    // 将p和q的根节点统一
    int pRoot = find(p);
    int qRoot = find(q);
    if (pRoot != qRoot) {
        return;
    }
    id[pRoot] = qRoot;
    count--;
}

算法复杂度分析

• quick-union与quick-find基于同样的数据结构————以触点作为索引的id[]数组。
  但实际上他实现了树的数据结构。
• 分析quick-union算法的成本比分析quick-find算法的成本更困难，因为这依赖于输入的特点。
• 在最好的情况下，find()只需要访问数组一次就能得到一个触点所在分量的标识符。
• 而在最坏的情况下，这需要2N-1次数组访问。
• 由此我们不难构造一个最佳的输入情况，使得用例的时间复杂度为线性级别。
• 我们也可以构造一个最坏的输入，让用例的运行时间是平方级别。