union如何找到二次算法？

Question

In this implementation of Quick Find algorithm, Constructor takes N steps so does union() .

The instructor said that union is too expensive as it takes N^2 to process sequence of N union commands on N objects, How can union be quadratic when it accesses array elements one at a time?

public class QuickFind
{
    private int[] id;

    public QuickFind(int N) {
        id = new int[N];
        for (int i=0; i<N; i++) {
            id[i] = i;
        }
    }

    public boolean connected(int p, int q) {
        return id[p] == id[q];
    }

    public void union(int p, int q) {
        int pid = id[p];
        int qid = id[q];

        for (int i=0; i<id.length; i++)
            if (id[i] == pid)
                id[i] = qid;
    }
}

Answer 1

Each invocation of union method requires you iterate over the id array, which takes O(n) time. If you invoke union method n times, then the time required is n*O(n) = O(n^2) .

You can improve time complexity of union method to O(1) , by making the time complexity of connected method higher, probably O(log n) , but this is just one time operation. I believe that your text book explain this in details.

Answer 2

Union operation for Quick Find is quadratic O(n^2) for n operations, because each operation takes O(n) time, as is easy to notice in for loop inside union(int p, int q)

    for (int i=0; i<id.length; i++)

Notice that the algorithm is called Quick Find , as each find ( connected(int p, int q) ) operation takes constant time. However for this algorithm you end up paying in union operation, as mentioned in your question.

There is another algorithm Quick Union , which improves time for union operation. But then find doesn't remain O(1) (but better than linear time).