图的深度优先与广度优先（dfs和bfs）思路记录

介绍：

深度优先搜索是一种递归的搜索算法，其主要思想是尽可能深地搜索一个分支，直到无法继续下去，然后回溯到前一个节点，再继续搜索其他分支。
广度优先搜索是一种迭代的搜索算法，其主要思想是从起始节点开始，逐层遍历相邻节点，直到找到目标节点或遍历完整个图。

属性介绍：
ArrayList<String> vertexList 储存每个节点的名字
int[][] edges 储存图的邻结矩阵
boolean[] isVisited; 记录某个节点是否已被访问

深度优先算法（dfs）：

图解：由1出发先到节点2（因为是以12345678存数据）然后先到节点4然后先到节点8，然后节点8会得到他的临结节点4，但是已经被访问，所以会再找到没被访问的5，然后5的临结节点都被访问过了，最后回溯8 4 2都没有属于他们的临结节点，因为2的临结节点5已被访问。得到1-2-4-8-5

当回溯到1，则可以到节点3，然后先到节点6，节点6会先找到临结节点3，但是已经被访问，所以会找节点7且访问，最后节点7的临结节点3和6已经被访问了，所以开始回溯6 3 1，6 3 1都没有其它未被访问的临结节点，线程结束。得到3-6-7

结合后1-2-4-8-5-3-6-7

步骤：

①遍历判断每个节点是否被访问，如果已被访问则跳到下一个节点，否则进入第②步  98行代码

②输出目前这个节点a，并且将其isVisited值变为true。 82、83行代码

③通过getFirstNeighbor方法，得到目前这个节点a的下一个邻结节点下标b， 84行代码

情况1：如果返回-1则没有邻结节点，说明没有连该节点，返回第①步跳到下一个未被访问的节点。

情况2：如果有则判断b是否被访问(87行代码)，如果已被访问则通过getNextNeighbor方法获取目前这个节点a的下一个非b的邻结节点c， 90行代码

然后再次判断是否被访问(87行代码)，如果得到邻结c是未访问则递归传入节点c，重复进行②③的步骤。

• 总结：

  • 假设初始状态是图中所有顶点均未被访问
  • 从某个顶点出发，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。
  • 若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。

广度优先算法（bfs）：

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

图解：

从节点1开始，然后会找到2和3。
通过2开始找到4和5。
通过3开始找到6和7。
通过4开始找到8。
通过5找到8但是已经被访问
结合后：12345678
ps：2和3都是1的下一层，属于同一层，所以先后输出。 123
4和5属于2的下一层  123+45
6和7属于3的下一层  12345 + 67

8是4和5的下一层，所以是最后输出  1234567+8

步骤：

这个内容由于韩顺平老师的步骤更清晰易懂，我也没什么卡壳的地方，所以就直接粘贴上韩顺平老师的步骤大家一起学习

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

运行代码：

package ysh.Graph;

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

public class GraphDemo {
    private ArrayList<String> vertexList; //存储顶点集合
    private int[][] edges; //存储图对应的邻结矩阵
    //定义给数组 boolean[], 记录某个结点是否被访问
    private boolean[] isVisited;
    public static void main(String[] args) {
        String Vertexs[] = {"1", "2", "3", "4", "5", "6", "7", "8"};
        int n = Vertexs.length; //结点的个数
        //创建图对象
        GraphDemo graph = new GraphDemo(n);
        //循环的添加顶点
        for(String vertex: Vertexs) {
            graph.insertVertex(vertex);
        }
        //边的关系
        graph.insertEdge(0, 1, 1);
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);
        graph.insertEdge(3, 7, 1);
        graph.insertEdge(4, 7, 1);
        graph.insertEdge(2, 5, 1);
        graph.insertEdge(2, 6, 1);
        graph.insertEdge(5, 6, 1);
        //显示邻结矩阵
        graph.showGraph();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {

        }

        System.out.println("深度遍历");
        graph.dfs(); // A->B->C->D->E [1->2->4->8->5->3->6->7]
        System.out.println();
        System.out.println("广度优先!");
        graph.bfs(); // A->B->C->D-E [1->2->3->4->5->6->7->8]
    }
    //构造器
    public GraphDemo(int n) {
//初始化矩阵和 vertexList
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
    }
//得到第一个邻接结点的下标 w
    /**
     *
     * @param index
     * @return 如果存在就返回对应的下标，否则返回-1
     */
    public int getFirstNeighbor(int index) {
        for(int j = 0; j < vertexList.size(); j++) {
            if(edges[index][j] > 0) {
                return j;
            }
        }
        return -1;
    }
    //根据前一个邻接结点的下标来获取下一个邻接结点
    public int getNextNeighbor(int v1, int v2) {
        for(int j = v2 + 1; j < vertexList.size(); j++) {
            if(edges[v1][j] > 0) {
                return j;
            }
        }
        return -1;
    }
    //深度优先遍历算法
//i 第一次就是 0
    private void dfs(boolean[] isVisited, int i) {
        System.out.print(vertexList.get(i));
        isVisited[i]=true;
        int w=getFirstNeighbor(i);
        while(w!=-1){
            //找到了第一个点
            if(!isVisited[w]){
                dfs(isVisited,w);
            }
            w=getNextNeighbor(i,w);
        }
    }
    //对 dfs 进行一个重载, 遍历我们所有的结点，并进行 dfs
    public void dfs() {
        isVisited=new boolean[vertexList.size()];
        for(int i=0;i<isVisited.length;i++){
            if(!isVisited[i]){
                dfs(isVisited,i);
            }
        }

    }

    /**
     * 广度优先遍历算法步骤
     * 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
     */
    private void bfs(boolean[] isVisited, int i) {
        int u ; // 表示队列的头结点对应下标
        int w ; // 邻接结点 w
        LinkedList queue = new LinkedList();
        //访问初始结点 v 并标记结点 v 为已访问。结点 v 入队列
        System.out.print(vertexList.get(i));
        isVisited[i] = true;
        queue.addLast(i);
        while(queue.size()>0){//当队列非空时，继续执行，否则算法结束。
            //出队列，取得队头结点 u。
            u=(Integer)queue.removeFirst();
            //查找结点 u 的第一个邻接结点 w。
            w=getFirstNeighbor(u);
            while(w!=-1){//若结点 u 的邻接结点 w 不存在，则转到步骤 3(上面那个while)
                if(!isVisited[w]){
                    //6.1 若结点 w 尚未被访问，则访问结点 w 并标记为已访问。
                    //6.2 结点 w 入队列
                    System.out.print(vertexList.get(w));
                    isVisited[w]=true;
                    queue.add(w);
                }
                //查找结点 u 的继 w 邻接结点后的下一个邻接结点 w，转到步骤 6
                w=getNextNeighbor(u,w);
            }
        }

    }

    //遍历所有的结点，都进行广度优先搜索
    public void bfs() {
        isVisited=new boolean[vertexList.size()];
        for(int i=0;i<vertexList.size();i++){
            if(!isVisited[i]){
                bfs(isVisited,i);
            }
        }
    }
    //图中常用的方法
//返回结点的个数
    public int getNumOfVertex() {
        return vertexList.size();
    }
    //显示图对应的矩阵
    public void showGraph() {
        for(int[] link : edges) {
            System.err.println(Arrays.toString(link));
        }
    }
    //返回结点 i(下标)对应的数据 0->"A" 1->"B" 2->"C"
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

    //插入结点
    public void insertVertex(String vertex) {
        vertexList.add(vertex);
    }
//添加边
    /**
     *
     * @param v1 表示点的下标即使第几个顶点 "A"-"B" "A"->0 "B"->1
     * @param v2 第二个顶点对应的下标
     * @param weight 表示
     */
    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
    }
}