图的深度优先和广度优先——java

借鉴：https://www.cnblogs.com/lanjianqing/p/4125134.html
理解是自己的，供大家学习。

测试数据

char[] vertex={'A','B','C','D','E','F','G','H','I'};
        int[][] edges = {
                { 0, 1, 0, 0, 0, 1, 1, 0, 0 }, { 1, 0, 1, 0, 0, 0, 1, 0, 1 }, { 0, 1, 0, 1, 0, 0, 0, 0, 1 },
                { 0, 0, 1, 0, 1, 0, 1, 1, 1 }, { 0, 0, 0, 1, 0, 1, 0, 1, 0 }, { 1, 0, 0, 0, 1, 0, 1, 0, 0 },
                { 0, 1, 0, 1, 0, 1, 0, 1, 0 }, { 0, 0, 0, 1, 1, 0, 1, 0, 0 }, { 0, 1, 1, 1, 0, 0, 0, 0, 0 }
        };
        Graph graph = new Graph(vertex, edges);
        graph.DFS();

广度优先

    //广度优先
    public void BFS(){
        Queue<Integer> queue=new LinkedList<>();
        for(int i=0;i<vertexs.length;i++){
            if(flag[i]==false){
                flag[i]=true;//遍历到A
                System.out.println(vertexs[i]+" ");
                queue.add(i);//把A加入队列
                while (!queue.isEmpty()){
                    Integer j = queue.poll();//和j相连的
                    for(int k=0;k<vertexs.length;k++){
                        if(edges[j][k]==1&&flag[k]==false){//和j相连同时没有被访问过 BEG
                            flag[k]=true;
                            System.out.print(vertexs[k]+" ");
                            queue.add(k);
                        }
                    }
                    System.out.println();
                }
            }
        }
    }

理解

先遍历A，把A加入队列
然后遍历所有和A相连的节点并且该节点并没有被访问过，遍历过后把这些节点加入队列
此时与A连的已经变量完了，相当于第一梯队已经遍历完了，要遍历第二梯队，即BFG的下一个且仅一个
后续过程都如此，每次仅遍历一层，一层一层往下
由于存放节点的是队列先进先出，所有有顺序

结果：

深度优先

    public void DFS(){
        for(int i=0;i<vertexs.length;i++){
            if(flag[i]==false){
                forDFS(i);
            }
        }
    }

    public void forDFS(int i){
        flag[i]=true;
        System.out.print(vertexs[i]+" ==");
        for(int j=0;j<vertexs.length;j++){
            if(flag[j]==false&&edges[i][j]==1){
                forDFS(j);
            }
        }
    }

理解