Networkx：通过波遍历图

Question

Suppose i have a following graph in networkx

import networkx as nx

g = nx.Graph()
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(3, 1)
g.add_edge(4, 2)

So it's basically 3-1-0-2-4 line.

Is there are a networkx way to perform BFS search by "waves"? Something like this:

for x in nx.awesome_bfs_by_waves_from_networkx(g, 0):
    print(x)
# should print
# [1, 2]
# [3, 4]

In other words i want to find all 1-ring neighborhood, then 2-ring, etc.

I'm able to do this by using Queue, but i interested in using networkx tools if it possible. Also it's possible to use multiple iterators with different depth_limit values, but i hope that it's possible to find more beautiful way.

UPD: It's important for me to have a lazy solution which will not require to traverse whole graph, because my graph can be quite big and i want to be able to stop traversing early if it needed.

Answer 1

You can calculate shortest paths from 0 (or any other node n ) using Dijkstra algorithm and then group the nodes by distance:

from itertools import groupby
n = 0
distances = nx.shortest_paths.single_source_dijkstra(g, n)[0]
{node: [node1 for (node1, d) in y] for node,y 
                                   in groupby(distances.items(), 
                                              key=lambda x: x[1])}
#{0: [0], 1: [1, 2], 2: [3, 4]}

If you want to proceed by rings (also known as crusts ), use the concept of the neighborhood:

core = set()
crust = {n} # The most inner ring
while crust:
    core |= crust
    # The next ring
    crust = set.union(*(set(g.neighbors(i)) for i in crust)) - core

Answer 2

The function nx.single_source_shortest_path_length(G, source=0, cutoff=7) should provide the information you need. But it returns a dict keyed by node to distance from source. So you have to process it to get it into groups by distance. Something like this should work:

from itertools import groupby
spl = nx.single_source_shortest_path_length(G, source=0, cutoff=7)
rings = [set(nodes) for dist, nodes in groupby(spl, lambda x: spl[x])]