算法（Algorithms）第4版 练习 1.5.1

id数组的变化情况：

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

操作次数分析：

find()函数每次调用访问数组1次。

connected函数每次调用两次find()函数，故访问数组2次。

union函数访问数组的次数为：2 + N + （1，N-1）。其中2为两次调用find（）函数，N为N次数组判断，（1，N-1）为可能的数组替换次数。

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

对于这个client，对每个数据对，都调用一次connected函数和union函数。

下边对数组访问次数进行分析：

9 0：2 + 　　2 + 10 + 1

3 4：2 +　　 2 + 10 + 1

5 8：2 + 　　2 + 10 + 1

7 2：2 + 　　2 + 10 + 1

2 1：2 + 　　2 + 10 + 2

5 7：2 + 　　2 + 10 + 2

0 3：2 + 　　2 + 10 + 2

4 2：2 + 　　2 + 10 + 4

源代码：

package com.qiusongde;

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

public class UFQuickFind {
    
    private int[] id;//access to component id (site indexed)
    private int count;//number of components
    
    public UFQuickFind(int n) {
        //initialize count and id
        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 find(p) == find(q);
    }
    
    public int find(int p) {
        return id[p];
    }
    
    public void union(int p, int q) {
        
        int pID = find(p);
        int qID = find(q);
        
        //do nothing if p and q are already
        //in the same component
        if(pID == qID) 
            return;
        
        //rename p's component to q's name
        for(int i = 0; i < id.length; i++) {
            if(id[i] == pID)
                id[i] = qID;
        }
        count--;
        
    }
    
    @Override
    public String toString() {
        String s = "";
        
        for(int i = 0; i < id.length; i++) {
            s += id[i] + " ";
        }
        s += "
" + count + " components";
        
        return s;
    }

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

}