图的深度优先遍历（DFS）和广度优先遍历（BFS）

深度优先遍历（DFS）

图的遍历：即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种访问策略: (1)深度优先遍历 (2)广度优先遍历

图的深度优先搜索(Depth First Search) 。

1：深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。    2：我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。 显然，深度优先搜索是一个递归的过程

深度优先遍历算法步骤

1：访问初始结点v，并标记结点v为已访问。 2：查找结点v的第一个邻接结点w。 3：若w存在，则继续执行。如果w不存在，则回到第1步，将从v的下一个结点继续。4：若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123）。 5：若w被访问过，查找结点v的w邻接结点的下一个邻接结点，转到步骤3。

通俗理解：

不小心删了……

广度优先遍历（BFS）

图的广度优先搜索(Broad First Search) 。 类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点

广度优先遍历算法步骤

 1：访问初始结点v并标记结点v为已访问。 2：结点v入队列 。3：当队列非空时，继续执行，否则算法结束。 4：出队列，取得队头结点u。 5：查找结点u的第一个邻接结点w。 6：若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤： 6.1 若结点w尚未被访问，则访问结点w并标记为已访问。 6.2 结点w入队列 。6.3 查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。

通俗理解：

上图中，我们顶点顺序设为ABCDE，1：从A行开始遍历，把A记录为已经遍历过，把A加入一个队列；2：判断队列是不为空，弹出队列的第一个元素即A（此时队列里面A已经删除），获取A的相邻节点B，把A记录为已经遍历过，把B加入队列；3；判断队列是不为空，弹出队列的第一个元素即B（弹出后队列有C），发现相邻结点B已经被遍历，就获取下一个相邻节点C，把C记录为已经遍历过，把C加入队列；4：发现A行已经没有相邻结点，判断队列是不为空，就弹出队列的第一个元素即B，发现C的相邻节点AC已经被遍历过，就获取相邻节点D，把D记录为已经遍历过，把D加入队列；5：然后继续获取B的相邻节点D之后的一个相邻节点E，把E记录为已经遍历过，把E加入队列；6：发现B已经没有相邻结点，就判断队列是不为空，弹出队列的第一个元素即C（弹出后队列有DE）；7发现C结点的相邻节点都已经被遍历后，就判断队列是不为空，弹出队列的第一个元素即D（弹出后队列有E）；8：发现D结点的相邻节点都已经被遍历后，就判断队列是不为空，弹出队列的第一个元素即E（弹出后队列为空）；9：发现E结点的相邻节点都已经被遍历后，此时判断队列为空，则A节点的广度遍历结束；10：BCDE重复上述步骤

两种遍历的实现案例：

package com.atgguigu.graph;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

public class Graph {
    private ArrayList<String> vertexList; //顶点集合
    private int[][] edges; //存储图的领结矩阵
    private int num; //边的数量

    private boolean[] flag ; //判断节点是否被访问过
    private int n; //优化，记录深度遍历的个数

    public Graph(int n){
        edges = new int[n][n];
        vertexList = new ArrayList<>(n);
        flag = new boolean[5];
        num = 0;
    }

    public static void main(String[] args) {
        int n =5;
        String[] VertexValue = {"A","B","C","D","E"};

        Graph graph = new Graph(5);

        for (String s : VertexValue) {
            graph.insert(s);
        }

        graph.insertEdge(0,1,1);
        graph.insertEdge(0,2,1);
        graph.insertEdge(1,2,1);
        graph.insertEdge(1,3,1);
        graph.insertEdge(1,4,1);

        graph.showGraph();

//        graph.dfs(); //深度遍历:A>B>C>D>E

        graph.bfs(); //广度遍历:A>B>C>D>E

    }

    /**
     * 深度优先遍历一个
     */
    private void dfs(boolean[] flag,int i){
        //首先访问该节点
        System.out.print(getValue(i)+">>>");
        n++;
        //将该节点设置为已访问
        flag[i] = true;
        //判断该节点是否存在领结点
        int w = getFirstVertex(i);
        //有领结点
        while (w!=-1){
            if(!flag[w]){ //没有被访问过
                dfs(flag,w);
            }
            //被访问过，获取被访问过结点i的第二的领结点
            w = getNextIndex(i,w);
        }
    }

    /**
     * 深度优先遍历所有结点
     */
    public void dfs(){
        for (int i=0;i<vertexList.size();i++){
            if(n<vertexList.size()){
                if(!flag[i]){
                    dfs(flag,i);
                }
            }
        }
    }

    /**
     * 一个结点广度优先遍历
     */
    public void bfs(boolean[] flag,int i){
        int u; //队列头结点下标
        int w; //领结点的下标
        LinkedList<Integer> queue = new LinkedList<>(); //访问节点顺序
        System.out.print(getValue(i)+">>>");
        //标记该结点已访问
        flag[i] = true;
        //结点加入队列
        queue.addLast(i);

        while (!queue.isEmpty()){
            //取出头结点下标
            u = queue.removeFirst();
            //得到第一个领结点下标
            w = getFirstVertex(u);
            //有领结点
            while (w!=-1){
                if(!flag[w]){ //没有被访问过
                    System.out.print(getValue(w)+">>>");
                    flag[w] = true;
                    queue.addLast(w);
                }
                //被访问过，获取被访问过结点i的第二的领结点
                w = getNextIndex(u,w);
            }
        }
    }

    /**
     * 广度优先遍历所有节点
     */
    public void bfs(){
        for (int i=0;i<vertexList.size();i++){
            if(!flag[i]){
                bfs(flag,i);
            }
        }
    }

    /**
     * 传入一个结点下标，判断该节点是否存在领结点
     * @param index
     * @return
     */
    public int getFirstVertex(int index){
        for(int i=0;i<vertexList.size();i++){
            if(edges[index][i] >0 ){
                return i;
            }
        }
        return -1;
    }

    /**
     * 根据一个被访问过的结点下标获取下一个结点下标
     */
    public int getNextIndex(int v1,int v2){
        for (int i =v2+1;i<vertexList.size();i++){
            if(edges[v1][i] > 0){
                return i;
            }
        }
        return -1;
    }

    /**
     * 插入顶点
     * @param vertex
     */
    public void insert(String vertex){
        vertexList.add(vertex);
    }

    /**
     * 插入边
     * @param v1 顶点的下标
     * @param v2 顶点的下标
     * @param weight 1，0
     */
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        num++;
    }

    /**
     * 返回结点数
     * @return
     */
    public int getVertexList(){
        return vertexList.size();
    }

    /**
     * 返回边数
     * @return
     */
    public int getNum(){
        return num;
    }

    /**
     * 返回对应下标的顶点
     * @param i
     * @return
     */
    public String getValue(int i){
        return vertexList.get(i);
    }

    /**
     * 返回对应顶点的下标
     * @param s
     * @return
     */
    public int getIndex(String s){
        for(int i=0;i<vertexList.size();i++) {
            if (vertexList.get(i).equals(s)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 返回两个顶点的权值
     * @param v1
     * @param v2
     * @return
     */
    public int getWeight(int v1,int v2){
        return edges[v1][v2];
    }

    /**
     * 显示图
     */
    public void showGraph(){
        for (int[] edge : edges) {
            System.out.println(Arrays.toString(edge));
        }
    }




}

小结：

深度遍历：往下遍历

广度遍历：横向遍历