Java 生成图的BFS森林

我想生成一个DAG（直接非循环图）的BFS林。这意味着我的树类需要是一个普通树，而不是二叉树（换句话说，当我生成一个林时，我无法提前知道一个节点将有多少子节点）。大部分代码都是在下面编写和显示的，但是我缺少一行，就我的一生而言，它让我无法理解

public Tree BFS(V start)
{
    reset();
    LinkedList<GraphMatrixVertex<V>> list = new LinkedList<GraphMatrixVertex<V>>();
    GraphMatrixVertex<V> vert = dict.get(start);
    Tree root = new Tree(vert); 
    list.add(vert);
    do
    {
        vert = list.getFirst();
        Iterator<V> ni = neighbors(start);
        while(ni.hasNext())
        {
            V v = ni.next();
            GraphMatrixVertex<V> vtx = dict.get(v);
            if(!vtx.isVisited())
            {
                list.add(vtx);
                            vtx.visit();
                root.addChild(new Tree(vtx));
            }
        }
    //code goes here
    }
    while(!list.isEmpty());

    return root;
}

公共树BFS（V开始）
{
重置（）；
LinkedList=新建LinkedList（）；
GraphMatrix顶点顶点顶点=dict.get（开始）；
树根=新树（垂直）；
列表。添加（垂直）；
做
{
vert=list.getFirst（）；
迭代器ni=邻居（开始）；
while（ni.hasNext（））
{
V=ni.next（）；
GraphMatrix顶点vtx=dict.get（v）；
如果（！vtx.isvisted（））
{
列表。添加（vtx）；
vtx.visit（）；
addChild（新树（vtx））；
}
}
//代码在这里
}
而（！list.isEmpty（））；
返回根；
}

我的树类存储一个值参数、一个父引用和一个子类列表。 我的问题是引用下一个树节点。将所有未访问的邻居添加为当前节点的子节点后，如何到达下一个节点

编辑：

所以看起来像这样

public void bfs(Tree parent)
{   
    Iterator<V> ni = neighbors((V) parent.value());
    if(ni.hasNext())
    {
            while(ni.hasNext())
            {
            V next = ni.next();
            GraphMatrixVertex<V> vert = dict.get(next);
            if(!vert.isVisited())
                parent.addChild(new Tree(next));
        }   
    }
}

public void bfs（树父级）
{   
迭代器ni=邻居（（V）parent.value（））；
if（ni.hasNext（））
{
while（ni.hasNext（））
{
V next=ni.next（）；
GraphMatrix顶点顶点顶点=dict.get（下一步）；
如果（！vert.isVisited（））
addChild（新树（下一个））；
}   
}
}

---

递归调用到哪里去了？

如果我正确理解了您的问题，您可以使用递归进行此操作。基本上，您有一个函数，该函数创建一层节点，然后为要创建/访问的每个子节点再次调用自身

编辑：

好的，我编辑了你的代码。首先，我删除了if（hasNext）作为其内部while循环的冗余。对于邻居列表中的每个子节点，创建一个新的树节点，然后运行其bfs（）方法，将当前树对象传入。函数返回一个列表，该列表应该是通过树的最佳路径。我也不确定你是如何得到你的相邻节点，它看起来有点奇怪。我也没有测试过代码，所以里面可能有打字错误和其他东西，但希望它能让你了解如何进行搜索。哦，当你点击一个叶节点（你的目标？）时，它只需要设置它的权重，然后返回一个只有它自己的新列表

int weight; // this should be you node traversal cost

public LinkedList<Tree> bfs(Tree parent){

    Iterator<V> ni = neighbors((V) parent.value());

    LinkedList bestPath = null;       
    int bestScore = 0xFFFFFFFF;

    while(ni.hasNext()){
        V next = ni.next();
        GraphMatrixVertex<V> vert = dict.get(next);
        if(!vert.isVisited()){
            Tree newNode = new Tree(next);
            parent.addChild(newNode);
            LinkedList path = newNode.bfs(this);
                if(newNode.weight < bestScore){
                    bestScore = weight;
                    bestPath = path;
                }
        }
    }
    weight = bestScore + this.weight;
    bestPath.addFirst(this);
    return path;   
}

int-weight；//这应该是您的节点遍历成本
公共链接列表bfs（树父级）{
迭代器ni=邻居（（V）parent.value（））；
LinkedList bestPath=null；
int bestScore=0xFFFFFFFF；
while（ni.hasNext（））{
V next=ni.next（）；
GraphMatrix顶点顶点顶点=dict.get（下一步）；
如果（！vert.isVisited（））{
Tree newNode=新树（下一个）；
parent.addChild（newNode）；
LinkedList path=newNode.bfs（此）；
if（newNode.weight

编辑2：

public void bfs(Tree parent){

    Iterator<V> ni = neighbors((V) parent.value());

    while(ni.hasNext()){
        V next = ni.next();
        GraphMatrixVertex<V> vert = dict.get(next);
        if(!vert.isVisited()){
            Tree newNode = new Tree(next);
            parent.addChild(newNode);
            newNode.bfs(this);
        }
    }
}

public void bfs（树父级）{
迭代器ni=邻居（（V）parent.value（））；
while（ni.hasNext（））{
V next=ni.next（）；
GraphMatrix顶点顶点顶点=dict.get（下一步）；
如果（！vert.isVisited（））{
Tree newNode=新树（下一个）；
parent.addChild（newNode）；
bfs（这个）；
}
}
}

我不确定您为什么有分数和路径变量。这不是BFS算法中考虑的问题。至于'if（ni.hasNext（））'行，为了递归，我把它留在那里，这样当在没有邻居的节点上调用它时，它不会返回任何内容。不过为了澄清一下，我正在生成一棵树，表示一个图的bfs搜索。我不想遍历一棵树并生成一个列表。好吧，这样可以简化一些事情。您只需执行您正在执行的操作，然后再次调用该函数。请参见编辑#2