Java 在有向图中，如何从某个顶点开始计算BFS或DFS，其中某些顶点的出度为0？

如果我们想从给定的顶点执行DFS/BFS，那么图的DFS或BFS遍历的顺序是什么

下面是一个图的BFS实现

import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Queue;

public class BreadthFirstSearch {

    static class Graph {
        int V;
        LinkedList[] vertexList;

        Graph(int v) {
            this.V = v;
            vertexList = new LinkedList[v];

            for (int i = 0; i < v; i++) {
                vertexList[i] = new LinkedList<>();
            }
        }
    }

    private void addEdge(Graph graph, int src, int dest) {
        graph.vertexList[src].add(dest); // Directed Graph Only
    }

    private void bfs(Graph graph, int vertex) {

        if (vertex > graph.V) {
            throw new IllegalArgumentException("Value not defined");
        }
        boolean visited[] = new boolean[graph.V];

        Queue<Integer> queue = new LinkedList<>();

        queue.add(vertex);
        while (!queue.isEmpty()) {
            int a = queue.poll();
            if (!visited[a]) {
                System.out.print(a + " ");
                visited[a] = true;

            }
            for (Object o : graph.vertexList[a]) {
                int n = (int) o;
                if (!visited[n]) {
                    queue.add(n);
                }
            }
        }
    }

    private void traverseGraphList(Graph G) {
        int i = 0;
        for (LinkedList list : G.vertexList) {
            ListIterator itr = list.listIterator();
            System.out.print("src: " + i++ + " ");
            while (itr.hasNext()) {
                System.out.print(" -> " + itr.next());
            }
            System.out.println();
        }
    }

    public static void main(String args[]) {
        BreadthFirstSearch g = new BreadthFirstSearch();
        int n = 8;
        Graph graph = new Graph(n);
        g.addEdge(graph, 0, 1);
        g.addEdge(graph, 0, 2);
        g.addEdge(graph, 1, 2);
        g.addEdge(graph, 2, 0);
        g.addEdge(graph, 2, 3);
        g.addEdge(graph, 3, 3);
        g.addEdge(graph, 3, 4);
        g.addEdge(graph, 5, 4);
        g.addEdge(graph, 5, 6);
        g.addEdge(graph, 7, 6);
        System.out.println("BFS starting from node 2");
        g.bfs(graph, 2);

        System.out.println();
        g.traverseGraphList(graph);
        //2 0 3 1 4

    }
}

import java.util.LinkedList；
导入java.util.ListIterator；
导入java.util.Queue；
公共类横向优先搜索{
静态类图{
INTV；
LinkedList[]顶点列表；
图形（INTV）{
这个，V=V；
vertexList=新链接列表[v]；
对于（int i=0；i图形V）{
抛出新的IllegalArgumentException（“未定义值”）；
}
布尔值[]=新布尔值[graph.V]；
Queue Queue=new LinkedList（）；
添加（顶点）；
而（！queue.isEmpty（））{
int a=queue.poll（）；
如果（！已访问[a]）{
系统输出打印（a+“”）；
访问[a]=正确；
}
对于（对象o:graph.vertexList[a]）{
int n=（int）o；
如果（！已访问[n]）{
添加（n）；
}
}
}
}
私有void traverseGraphList（图G）{
int i=0；
对于（LinkedList列表：G.vertexList）{
ListIterator itr=list.ListIterator（）；
系统输出打印（“src:+i++”）；
while（itr.hasNext（））{
系统输出打印（“->”+itr.next（））；
}
System.out.println（）；
}
}
公共静态void main（字符串参数[]）{
BreadthFirstSearch g=新的BreadthFirstSearch（）；
int n=8；
图形=新图形（n）；
g、 加法（图，0，1）；
g、 加法（图，0，2）；
g、 附录（图1，2）；
g、 加法（图2，0）；
g、 附录（图2，3）；
g、 附录（图3，3）；
g、 附录（图3、4）；
g、 附录（图5，4）；
g、 附录（图5、6）；
g、 附录（图7、6）；
System.out.println（“从节点2开始的BFS”）；
g、 bfs（图2）；
System.out.println（）；
g、 图形列表（图形）；
//2 0 3 1 4
}
}

---

输出为

2 0 3 1 4

如果要遍历图形的所有节点，则应注意，由于存在无法从所选根节点访问的节点，因此在使用单个BFS/DFS时将无法遍历这些节点

节点的遍历顺序取决于BFS/DFS的实现。在您的情况下，这取决于将每个节点插入邻接列表的顺序

---

如果要遍历整个图，则应维护访问的节点，然后为每个未访问的节点运行BFS/DFS（例如，通过使用循环）。特别是，被遍历节点的出现顺序再次取决于实际循环的项目的顺序。

因此，从我所看到的，BFS的实现很好。在IMO中，当初始调用的输入为

vertex

参数设置了

2

时，它的输出就是我所期望的算法的标准实现

也就是说，并非所有有向图都可以从任何给定节点完全遍历。根据箭头的方向，当我开始遍历节点

2

，我实际上只能到达节点

0

、

1

、

3

和

4

。无法从节点

2

访问节点

5

、

6

和

7

，因为

5

指向

4

，但

4

不指向

5

---

如果要真正遍历整个图形，则需要修改BFS算法，以便在当前实现结束时，访问的

数组的长度小于
顶点列表的长度，然后，您需要在
vertexList
中找到下一个元素，该元素在两个数组的长度匹配之前不存在于
visted
中。
在图形中进行DFS或BFS遍历的顺序是什么，它们在队列中的位置取决于表示图形的数据结构、遍历图形的算法或两者。一般来说，没有一个圆锥阶。可能有定义顺序的特定实现，但我不知道这是DFS或BFS的要求。因此，在我的情况下，如果我使用堆栈/队列，遍历在到达4后停止，或者说我们最初通过4，但它找不到任何相邻节点，然后，我们可以随机选择任何尚未访问的节点，继续遍历并更新节点，直到到达另一个块吗？
然后，我们可以随机选择任何尚未访问的节点，继续遍历并更新节点，直到到达另一个块吗？
否，wold不是DFS或BFS。您所寻找的似乎更接近于检查图是否连接或是否可以创建生成树。或者您可能正在寻找通过可以覆盖图的最小节点集。您需要解释您希望通过遍历此图来实现什么