首先尝试在Python中遍历图的广度

Question

In my code, I am essentially trying to create an implementation of a data flow network. Although the particularities of how I am going about doing this aren't particularly important, I need some help to make the program go through the graph in a breadth first fashion. When I do this with my code:

def traverse(self):
    source = self._nodelist[0]
    self.sand_pile(source)
    return

def sand_pile(self, start):
    for sink in start._sinks:
        //ALGORITHM FOR SENDING DATA HERE
    for s in start._sinks:
        self.sand_pile(s)
    return

The compiler correctly goes through the first node and its sinks breadth first, but then when it goes on to repeat the process for the sinks, it starts to go depth first.

Another way of explaining this is the following: if the source of the graph has two or three sinks, each of which have two or three of their own sinks, the compiler will print them all out and pass the value to them successfully, but then will proceed to go depth first for the rest of the nodes until it reaches the end. Where am I going wrong in my logic?

PS If I am not explaining anything well, please leave a comment so I can clarify.

Answer 1

You are mixing BFS ( breadth first search ) and DFS ( depth first search ) in your approach.

When sending data in your sand_pile method, you iterate horizontally through all children of the current node, which probably is your approach of implementing a BFS. But as soon as the first level of children (or sinks in your case) is done, you perform a recursion step on each of the child nodes. This essentially results in a schema like this:

• Start sand_pile on node on level 0 (root node)
• Distribute data to all its children on level 1
• Start sand_pile on first children of level 1
• Distribute data to all of its children on level 2
• ... keep on going DFS with out-of-line data distribution

The flaw is, that you employ recursion for a BFS.

You can use a recursive descent (ie stack-like iteration) for DFS, but for BFS, you should create a buffer that contains all nodes in the desired order (ie queue-like iteration)

The steps can then be like the following

1. Get maximum depth of your tree
2. For each depth level, put all nodes that reside on that level into a list
3. Concatenate all lists to obtain something like [lvl0_node0, lvl1_node0, lvl1_node1, lvl1_node2, lvl2_node_0, ..., lvlN_nodeM]
4. Iterate over that queue