Python 如何使用递归获得节点邻居？

我对递归函数很新，我尝试用递归函数得到图中的节点邻居，图是这样的

sub_node = [ 
             #first
             [D, E, F], #A neighbors
             [F, G, H], #B neighbors
             [H, I],    #C neighbors

             #second --> do with first index in tree list above
             [J, K],    #D neighbors
             [L],       #F neighbors
             [L],       #H neighbors

             # --> second index
             [K, L], #E neighbors
             [G],    #L neighbors
             [M],    #I neighbors

             # --> third index
             [L], #F neighbors
             [L], #H neighbors

            ]

我想要得到这个图中每个节点的邻居的序列

首先，获取顶部第一个树节点的邻居

sub_node = [
             [D, E, F], #A neighbors
             [F, G, H], #B neighbors
             [H, I],    #C neighbors
            ]

这是我的问题

接下来，获取前一个邻居的邻居，获取节点邻居的顺序是使用子_节点中所有列表第一个列表的第一个索引，然后再次使用所有列表的下一个索引，直到超出索引。 如果使用sub_节点执行，则其输出如下

sub_node = [ 
             #first
             [D, E, F], #A neighbors
             [F, G, H], #B neighbors
             [H, I],    #C neighbors

             #second --> do with first index in tree list above
             [J, K],    #D neighbors
             [L],       #F neighbors
             [L],       #H neighbors

             # --> second index
             [K, L], #E neighbors
             [G],    #L neighbors
             [M],    #I neighbors

             # --> third index
             [L], #F neighbors
             [L], #H neighbors

            ]

这是我的代码，我使用的图形库是NetworkX。 在我的函数中，它首先识别initail节点

import networkx as nx

G = nx.Graph()

G.add_edges_from([('A', 'D'), ('A', 'E'), ('A', 'F'), 
                ('B', 'F'), ('B', 'G'), ('B', 'H'), 
                ('C', 'H'), ('C', 'I'), 
                ('D', 'J'), ('D', 'K'), 
                ('E', 'K'), ('E', 'L'), 
                ('F', 'L'), 
                ('G', 'L'), 
                ('H', 'L'), 
                ('I', 'M')
                ])


def get_neighbors(G, initial_node):
    sub_node = []
    for n in initial_node:
        sub_node.append(list(nx.neighbors(G, n)))


initial_node = ['A', 'B', 'C'] #identify initial node first.
get_neighbors(G, initial_node)

现在我只能做这部分

sub_node = [
             [D, E, F], #A neighbors
             [F, G, H], #B neighbors
             [H, I],    #C neighbors
            ]

---

我真的不知道如何使用递归函数来完成剩余部分。

这种方法不使用递归，但我认为最好的办法是跟踪您知道的节点，您已经检查过的节点，并遍历您知道但尚未检查过的节点

将networkx导入为nx 最初设置图形 G=nx.图 G.从['A'，'D'，'A'，'E'，'A'，'F'，添加边， ‘B’、‘F’、‘B’、‘G’、‘B’、‘H’， ‘C’、‘H’、‘C’、‘I’， ‘D’、‘J’、‘D’、‘K’， ‘E’、‘K’、‘E’、‘L’， ‘F’、‘L’， ‘G’、‘L’， ‘H’、‘L’， “我是” ] 当前_节点=设置['A'，'B'，'C']我们的已知节点列表 checked_nodes=设置已检查节点的列表 节点_邻居={} 当前\u节点-选中的\u节点>0时： 首先，随机选择一个我们知道但尚未检查的新节点： 当前_节点=当前_节点-选中的_节点.pop 获取节点的邻居作为唯一元素： 邻居=setnx.neighborsG，当前节点 将我们不知道的任何结果添加到已知节点列表中： 当前_节点|=邻居 保存此节点的结果： 节点\邻居[当前\节点]=邻居 最后，标记已检查该节点，以便不再检查它： 选中\u节点。添加当前\u节点 printnode_邻居 {'C'：{'H'，'I'}，'H'：{'C'，'B'，'L'}，'B'：{'G'，'F'，'E'，'H'}，'A'：{'F'，'E'，'D'}，'D'：{'A'，'K'，'J'：{'D'}，'K'：{'E'，'D'}，'G'：{'B'，'L'}，'F'：{'B'，'A'，'L''E'：{'A'，'K'，'L''I''M'，'

---

为什么要用递归来做这件事？通过边缘列表的简单迭代将生成此表。另外，当networkx可以根据请求提供信息时，为什么要建立邻居列表？这里的第一个问题是我的问题是所需的输出？这是一种特殊的格式。对于->第二个索引，你把G和L弄混了吗？我假设您想要特定的子节点，或者不想要更高层的节点，因为中级节点的列表中没有更高层的节点？将每个孩子的第一个孩子分组，然后再将每个孩子的第二个孩子分组，这是一个期望的结果，还是您碰巧对它们进行了排序？