递归着色图的所有节点

Question

I have this problem where i want to color all nodes of a given graph,i create the below method (pseudo-code) to color one node at a time, the current browsed one(through the nodeIterator), (if a certain condition is met) whenever a neighbor of it is not colored. A node is colored if it is an element of vector . A node that is colored (with its pre-defined color), is a processed node. And if a node is processed then it should not be included in the coloring check of another neighbor (a colored node is removed from the process of coloring node). To note that conditionBetweenNodeAndNeighbor is checked between the current yet uncolored node, and a neigbor that is necessary not colored. here's my pseudo-code:

  #Recursive method colorNodes
    colorNodes(Graph graph,Iterator<Node> nodeIterator, Vector vector)
        if (vector.size() == graph.size())
            return true;
        node = nodeIterator.next();
        nodeNeighbors = node.getNeighbors();
        while(nodeNeighbors.hasnext()) {
            neighbor = nodeNeighbors.next();
            if (!nodeIsColored(vector, neighbor)) {
                if(conditionBetweenNodeAndNeighbor is true) {
                    vector.add(node) #color current node 
                    colorNodes(graph, nodeIterator,vector)#call recursively the method
                }
            }  
            else if (!nodeNeighbors.hasNext()) {
                    #potential last node or isolated node (having one neighbor only)
                  if(conditionBetweenNodeAndNeighbor is true) {
                    vector.add(node) #color last node anyway 
                    colorNodes(graph, nodeIterator,vector)#call recursively the method
                    }
                   }
            else {
                    continue;
                }
        }

Could anyone clarify how to approach this problematic and if my approach is correct (especially the cases differentiation)?

Answer 1

The main thing that stands out to me about your cases is that nodeNeighbors.next() is empty could cause problems. This is because nodeNeighbors seems to be an Iterator, which means that every time nodeNeighbors.next() is called, it will return the next object from the iterator and effect every future call of the function. It would be a good idea to use .nodeNeighbors.hasNext() instead.

If you want to color (as in add to the Vector) every node in a graph, recursively, including unconnected nodes, then you can actually use a much simpler algorithm.

colorNodes(Graph graph, Iterator<Node> nodeIterator, Vector vector) {
    if (nodeIterator.hasNext()) {
        node = nodeIterator.next();
        vector.add(node);
        colorNodes(graph, nodeIterator, vector);
    }
}

Although I suspect that you might want to only color nodes which are connected to other colored nodes, which would probably require a different approach. The algorithm doesn't need to be given an Iterator<Node>, just a single node. If the node is uncolored, then it colors that node and then evaluates the function on each uncolored neighbor. If you need to use the algorithm with some of the nodes already colored in, then you could write a external function that calls the recursive algorithm on each node already in a given Vector.

Note that the explanation in the paragraph above doesn't refer to the pseduocode sample above it, but instead to a hypothetical function/algorithm(s) that you could use if it was what you needed.

I hope this was helpful.