编写程序以为无向图标记连接的组件

Question

"Write a program to label the connected components for an undirected graph. In other words, all vertices of the first component are given the first component's label, all vertices of the second component are given the second Sec. 11.8 Projects 403 component's label, and so on. Your algorithm should work by defining any two vertices connected by an edge to be members of the same equivalence class. Once all of the edges have been processed, all vertices in a given equivalence class will be connected. Use the UNION/FIND implementation from Section 6.2 to implement equivalence classes."

/** General Tree class implementation for UNION/FIND */
class ParPtrTree {
    private Integer [] array; // Node array

    public ParPtrTree(int size) {
        array = new Integer[size]; // Create node array
        for (int i=0; i<size; i++)
            array[i] = null;
    }

    /** Determine if nodes are in different trees */
    public boolean differ(int a, int b) {
        Integer root1 = FIND(a); // Find root of node a
        Integer root2 = FIND(b); // Find root of node b
        return root1 != root2; // Compare roots
    }

    /** Merge two subtrees */
    public void UNION(int a, int b) {
        Integer root1 = FIND(a); // Find root of node a
        Integer root2 = FIND(b); // Find root of node b
        if (root1 != root2)
            array[root2] = root1; // Merge
    }

    /** @return The root of curr’s tree */
    public Integer FIND(Integer curr) {
        if (array[curr] == null)
            return curr; // At root
        while (array[curr] != null)
            curr = array[curr];
        return curr;
    }

Me and a few friends have been boggling our minds at how to approach this question, it isn't clear how the input is represented, we thought of implementing the general graph structures in Shaffer's Data Structures and Algorithm Analysis in Java, doing a breadth first search to organize it as a tree and reverse the pointers so it would fit into this data structure but I'm not sure that all of that random work really applies to what were trying to accomplish.

Has anyone ever had/done this problem before? Our professor didn't touch upon the question itself only had it listed in his homework.

Answer 1

Well, it looks like ParPtrTree implements an equivalence relation, although I can't figure out what Par and Ptr stand for. UNION(a,b) adds the equivalence a === b to the relation, and thus anything that a and b were already equivalent to, now all become equivalent to each other.

Without giving you too many details: I think that the assignment is suggesting simply that: for each node N in your graph, find all the nodes N _i for which there's an edge from N to N _i , and call UNION( N , N _i ). Once that's done, the equivalence classes in the equivalence relation correspond to the connected components of the graph. How you get those classes out of the ParPtrTree , I think you'll need to figure out, but consider using a HashSet to keep track of graph nodes you've already done something with. It would be best if you could add a method to ParPtrTree to get some information, because that method would be able to access array , but I don't know if you're allowed to do that.

Also, as I mentioned in a comment, using != on Integer objects doesn't work, because it compares references and not values. However, you can't blindly change it to use equals because the references could be null. To see if two Integer objects are equal, you need something like

a == b || (a != null && a.equals(b))

and to test if they're different, use ! on the whole thing.