union-find算法(数组实现版)

第一种通过遍历所有节点更新根节点(使同一连通分量指向同一点):find较快 故称这种做法为quick-find

QF.java

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

public class QF {
    private int[] id;
    private int count;
    public QF(int N)
    {
        id = new int[N];
        for (int i = 0; i < N; ++i)
            id[i] = i;
        count = N;
    }
    public boolean connect(int p,int q)
    {
        return find(p) == find(q);
    }
    public int find(int p)
    {
        return id[p];
    }
    public void union(int p,int q)
    {
        int l = find(p);
        int r = find(q);
        if (l == r) return;
        for (int i = 0; i < id.length; ++i)
        {
            if (id[i] == l)
                id[i] = r;
        }
        --count;
    }
    public int count()
    {
        return count;
    }
    // for test
    public void display()
    {
        for (int i = 0; i < id.length; ++i)
            StdOut.println(i + "--" + id[i]);
    }
    public void draw()
    {
        StdDraw.setXscale(-1,id.length + 2);
        StdDraw.setYscale(-1,id.length + 2);
        StdDraw.setPenRadius(0.07);
        for (int i = 0; i < id.length; ++i)
        {
            StdDraw.setPenColor(StdDraw.GREEN);
            StdDraw.point(i, id[i]);
            StdDraw.setPenColor(StdDraw.RED);
            StdDraw.text(i,id[i],Integer.toString(i)+ "--" + Integer.toString(id[i]));
        }
    }
}

测试结果(测试代码见后面的main.java)

第二种 通过find算法找出根节点通过连接根节点保持连通性(此时union速度提升 quick-union)
Fu.java

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

public class FU {
    private int[] id;
    private int count;
    public FU(int N)
    {
        id = new int[N];
        for (int i = 0;i < N; ++i)
            id[i] = i;
        count = N;
    }
    public boolean connect(int p,int q)
    {
        return find(p) == find(q);
    }
    public int find(int p)
    {
        while (id[p] != p)
            p = id[p];
        return p;
    }
    public void union(int p,int q)
    {
        int l = find(p);
        int r = find(q);
        if (l == r) return;
        id[l] = r;
        --count;
    }
    public int count()
    {
        return count;
    }
    public void display()
    {
        for (int i = 0; i < id.length; ++i)
            StdOut.println(i + "--" + id[i]);
    }
    public void draw()
    {
        StdDraw.setXscale(-1,id.length + 2);
        StdDraw.setYscale(-1,id.length + 2);
        StdDraw.setPenRadius(0.07);
        for (int i = 0; i < id.length; ++i)
        {
            StdDraw.setPenColor(StdDraw.GREEN);
            StdDraw.point(i, id[i]);
            StdDraw.setPenColor(StdDraw.RED);
            StdDraw.text(i,id[i],Integer.toString(i)+ "--" + Integer.toString(id[i]));
        }
    }
}

测试结果:

第三种 保持节点个数最小的连通分量成为较大的连通分量的子树(降低找根结点的复杂度) 即在原有的quick-union方法改进 成为 加权quick-union算法

AFU.java

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

public class AUF {
    private int[] id;
    private int[] sd;
    private int count;
    public AUF(int N)
    {
        id = new int[N];
        sd = new int[N];
        for (int i = 0; i < N; ++i)
        {
            id[i] = i;
            sd[i] = 1;
        }
        count = N;
    }
    public boolean connect(int p,int q)
    {
        return find(p) == find(q);
    }
    public int find(int p)
    {
        while (id[p] != p)
            p = id[p];
        return p;
    }
    public void union(int p,int q)
    {
        int l = find(p);
        int r = find(q);
        if (sd[l] > sd[r])
        {
            id[r] = l;
            sd[l] += sd[r];
        }
        else
        {
            id[l] = r;
            sd[r] += sd[l];
        }
    }
    public void display()
    {
        for (int i = 0; i < id.length; ++i)
            StdOut.println(i + "--" + id[i]);
    }
    public void draw()
    {
        StdDraw.setXscale(-1,id.length + 2);
        StdDraw.setYscale(-1,id.length + 2);
        StdDraw.setPenRadius(0.07);
        for (int i = 0; i < id.length; ++i)
        {
            StdDraw.setPenColor(StdDraw.GREEN);
            StdDraw.point(i, id[i]);
            StdDraw.setPenColor(StdDraw.RED);
            StdDraw.text(i,id[i],Integer.toString(i)+ "--" + Integer.toString(id[i]));
        }
    }
}

测试结果:

main.java

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

public class Main {
    public static void main(String[] args)
    {
        In in = new In("test.txt");
        FU fu = new FU(10);
        QF qf = new QF(10);
        AUF auf = new AUF(10);
        while (!in.isEmpty())
        {
            int l = in.readInt();
            int r = in.readInt();
            fu.union(l, r);
            qf.union(l, r);
            auf.union(l, r);
        }
        //StdOut.println("quick- find 实例");
        //qf.display();
        //StdOut.println("quick- union 实例");
        //fu.display();
        StdOut.println("加权 quick- union 实例");
        auf.display();
        //qf.draw();
        //fu.draw();

        auf.draw();
    }
}

测试数据: test.txt