图的广度优先遍历（Java实现）

文章收藏的好句子：这个世上，没有天上掉馅饼的灵感和等来的成就，只有日复一日的坚持和自律。

目录

1、图的广度优先遍历

     1、1 图的广度优先遍历基本思想

     1、2 图的广度优先遍历算法步骤

     1、3 图的广度优先遍历代码实现

1、图的广度优先遍历

1、1 图的广度优先遍历基本思想

在图的表现形式第一篇（Java实现）这篇文章中，我们学习了图的深度优先遍历，这篇文章我们主要是学习一下图的广度优先遍历，这里我先介绍一下图的广度优先遍历基本思想，为了方便好理解这个思想，我先画一张图，如图1所示；

它的思想：

（1）广度优先遍历，类似于分层搜索的过程；就拿图1来举例，A 顶点为第一层，B、C 顶点为第二层，D、E、F、G 顶点为第三层，H 顶点为第四层，搜索的过程先从第一层开始搜索，然后往下层搜索，这总能理解吧？

（2）广度优先遍历需要使用一个队列来保持访问过的节点的顺序，以便按照这个顺序来访问这些节点的邻接节点；就拿图1来举例，一开始先保存 A 顶点，然后把 A 顶点先访问，访问完 A 顶点后，把 A 顶点从队列中删除，然后再 A 顶点的所有邻接顶点（B、C）进行访问并把它们加入到队列中去，访问完 B、C 之后，又把 B 的邻接顶点（D、E）和 C 的邻接顶点（F、G）进行访问并把B、C 顶点进行删除，B、C 以下层的顶点以此类推......，其实说白了就是一层一层的进行访问，图1的广度优先遍历结果为 A->B->C->D->E->F->G->H 。

1、2 图的广度优先遍历算法步骤

说图的广度优先遍历算法步骤之前，我先以图1为例子，列举实现图1所用到的一些变量；

顶点数量 vertexNum 为8个，顶点列表 lstVertex 为 A、B、C、D、E、F、G、H，边的数量 edgeNum 为8，一开始队列 lstSearch 为空；用 isVisited 数组标记每个顶点是否被访问过，默认是没有被访问过，也就是每个元素值为 false ；边的二维数组 vertexPathArray 如图2所示（说明：1表示2个顶点直接相连接，0表示2个顶点没有直接相连接）；

它的算法步骤（注意：算法步骤看不懂的话，先看下面的代码实现，再回过头来看算法步骤就好理解了）：

（1）访问初始节点 index 并标记为已访问，其中 index 为顶点列表的索引，就拿图1来举例，index 为0 ，那么将  lstVertex.get(0) 取出来进行访问并将 isVisited[0] 置为 true，表示 lstVertex 的第0个元素已经被访问过。

（2）节点索引为 index 的入队列，广度遍历需要维护一个局部队列 lstSearch 。

（3）判断局部队列 lstSearch 的大小是否为0（一开始 lstSearch 的大小一定不为0），如果为0，那么就不执行从（4）开始之后的步骤；如果 lstSearch 的大小不为0，往下走（4）。

（4）如果 lstSearch 的大小不为0，那么就删除 lstSearch 的第一个索引并返回得到一个顶点列表 lstVertex 元素的索引（用 currIndex 表示删除 lstSearch 的第一个索引），那么就往下执行（5）；就拿图1举个例子，假设 lstSearch 的第一个索引的元素是 A，然后删除 lstSearch 的第一个索引，那么 A 在 lstVertex 中的索引是不是0，这样就得到顶点列表 lstVertex 元素的索引0 。

（5）获取索引为 currIndex（currIndex同时也为lstVertex中元素的索引） 的顶点的第一个邻接顶点，并将这个邻接顶点的索引置为 nextIndex，然后往下执行（6）。

（6）如果 nextIndex 为-1，那么执行（3）；如果 nextIndex 不为-1，那么往下执行（7）。

（7）如果 nextIndex 索引的顶点已经被访问，那么就获取索引为 currIndex 的下一个邻接顶点的索引，并把这个索引赋值给 nextIndex，然后执行（6）；如果 nextIndex 索引的顶点未被访问，那么将索引为 nextIndex 的顶点加入到队列 lstSearch 里面，并将 isVisited[nextIndex] 置为 true，用于标识该 nextIndex 索引的顶点已经访问，将 nextIndex 作为索引从顶点列表 lstVertex 中输出顶点，然后获取索引为 currIndex 的下一个邻接顶点的索引，并把这个索引赋值给 nextIndex，然后执行（6）。

图1的广度遍历过程是这样的：

（1）从 A 顶点开始访问并把 A 顶点添加到队列 lstSearch 中，然后又从队列 lstSearch 中删除 A 顶点，再查找 A 顶点的所有邻接顶点 B、C 将其（B、C）输出并把 B、C 加入到队列  lstSearch 中。

（2）从 lstSearch 中删除 B 顶点并找完 B 顶点的所有邻接顶点 D、E 将其（D、E）输出，然后将顶点 D、E 添加到 lstSearch 中。

（3）从 lstSearch 中删除 C 顶点并找完 C 顶点的所有邻接顶点 F、G 将其（F、G）输出，然后将顶点 F、G 添加到 lstSearch 中。

（4）从 lstSearch 中删除 D 顶点并找完 D 顶点的所有邻接顶点 H 将其（H）输出，然后将顶点 H 添加到 lstSearch 中。

1、3 图的广度优先遍历代码实现

我们用代码实现一把；

（1）创建一个图类 MyChart ：

package com.xiaoer.figure;


import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;


public class MyChart {


  /**
   * 创建图
   * @param vertexNum 顶点数量
   * @return 返回 MyChart 对象
   */
  public static MyChart createChart(int vertexNum) {
    MyChart myChart = new MyChart(vertexNum);
    myChart.addVertices();
    myChart.addEdges();
    return myChart;
  }


  /**
   * 添加所有边，添加的是2个顶点直接相连的边，看图5， A与B是不是有一条边直接相连接，indexOf 方法返回的是传入的顶点
   * 在一维数组的位置（也就是下标）
   */
  private void addEdges() {
    addEdge(indexOf("A"), indexOf("B"), 1);
    addEdge(indexOf("A"), indexOf("C"), 1);
    addEdge(indexOf("B"), indexOf("D"), 1);
    addEdge(indexOf("B"), indexOf("E"), 1);
    addEdge(indexOf("C"), indexOf("F"), 1);
    addEdge(indexOf("C"), indexOf("G"), 1);
    addEdge(indexOf("D"), indexOf("H"), 1);
    addEdge(indexOf("E"), indexOf("H"), 1);
  }


  /**
   * 添加所有顶点，看图5，是不是添加了A-H 这8个顶点
   */
  private void addVertices() {
    addVertex("A");
    addVertex("B");
    addVertex("C");
    addVertex("D");
    addVertex("E");
    addVertex("F");
    addVertex("G");
    addVertex("H");
  }


  /**
   * 顶点数量
   */
  private int vertexNum;


  /**
   * 顶点列表
   */
  private List<String> lstVertex;


  /**
   * 顶点路径
   */
  private int[][] vertexPathArray;


  /**
   * 边数量
   */
  private int edgeNum;


  /**
   * 是否已经被访问
   */
  private boolean[] isVisited;


  MyChart(int vertexNum) {
    this.vertexNum = vertexNum;
    lstVertex = new ArrayList<>(vertexNum);
    vertexPathArray = new int[vertexNum][vertexNum];
    isVisited = new boolean[vertexNum];
  }


  /**
   * 添加顶点, 此处不涉及扩容
   * 
   * @param vertex
   *            添加的顶点
   */
  void addVertex(String vertex) {
    if (vertexNum == lstVertex.size()) {
      throw new ArrayIndexOutOfBoundsException("数组已满");
    }
    lstVertex.add(vertex);
  }


  /**
   * 返回顶点所在的索引
   * @param vertex 目标顶点
   * @return 返回下标
   */
  int indexOf(String vertex) {
    return lstVertex.indexOf(vertex);
  }


  /**
   * 添加边
   * @param xIndex 横坐标
   * @param yIndex 纵坐标
   * @param weight 边的权重，weight = 1，表示2个顶点之间之间相连，就成了边
   */
  void addEdge(int xIndex, int yIndex, int weight) {
    if (xIndex >= vertexNum || yIndex >= vertexNum) {
      throw new IndexOutOfBoundsException("索引越界");
    }
    vertexPathArray[xIndex][yIndex] = weight;
    vertexPathArray[yIndex][xIndex] = weight;
    edgeNum++;
  }


  /**
   * 获取边数量
   * @return 返回边数量
   */
  int getEdgeNum() {
    return edgeNum;
  }


  /**
   * 获取下一个邻接节点
   * @param index 当前顶点的横坐标
   * @param nextIndex 当前顶点的前一个邻接顶点的纵坐标
   * @return
   */
  private int getNextNeighbor(int index, int nextIndex) {


    /**
     * i一开始为当前顶点的前一个邻接顶点的纵坐标+1算起，
     * 举例：看图5，边的二维数组（vertexPathArr）为：
     *   A B C D E F G H
         * A 0 1 1 0 0 0 0 0
         * B 1 0 0 1 1 0 0 0
         * C 1 0 0 0 0 1 1 0
         * D 0 1 0 0 0 0 0 1
         * E 0 1 0 0 0 0 0 1
         * F 0 0 1 0 0 0 0 0
         * G 0 0 1 0 0 0 0 0
         * H 0 0 0 1 1 0 0 0
     * 
     * 假设当前顶点为A顶点，已经查找完A顶点的第一个邻接顶点B，A所在的行坐标index就为0， B在第0行的第1列（nextIndex =
     * 1）对不对，那么查找A的下一个邻接顶点是不是从 从第2列（nextIndex+1）开始查找
     */
    for (int i = nextIndex + 1; i < lstVertex.size(); i++) {
      if (vertexPathArray[index][i] > 0) {
        return i;
      }
    }
    return -1;
  }


  /**
   * 获取第一个邻接节点 
   * @param index 表示行坐标
   * @return
   */
  private int getFirstNeighbor(int index) {
    
    /**
     * i一开始为0，表示从第0列开始查找
     * 举例：看图5，边的二维数组（vertexPathArr）为：
     *   A B C D E F G H
         * A 0 1 1 0 0 0 0 0
         * B 1 0 0 1 1 0 0 0
         * C 1 0 0 0 0 1 1 0
         * D 0 1 0 0 0 0 0 1
         * E 0 1 0 0 0 0 0 1
         * F 0 0 1 0 0 0 0 0
         * G 0 0 1 0 0 0 0 0
         * H 0 0 0 1 1 0 0 0
     * 
     * 假设当前顶点为C顶点，已经查找完C顶点的第一个邻接顶点A，C所在的行坐标index就为2， 
     * 那么查找C顶点的第一个邻接顶点是不是从第2行的第0列开始查找呢
     */
    for (int i = 0; i < lstVertex.size(); i++) {
      if (vertexPathArray[index][i] > 0) {
        return i;
      }
    }
    // 如果没有找到, 直接返回-1
    return -1;
  }


  /**
   * 广度优先遍历
   */
  public void bfs() {
    bfs(0);
  }


  private void bfs(int index) {
    LinkedList<Integer> lstSearch = new LinkedList<>();


    System.out.print(lstVertex.get(index) + " -> ");


    // 添加节点到集合
    lstSearch.add(index);


    // 标识节点为已经遍历
    isVisited[index] = true;


    // 队列不为空, 进行顺序处理
    for (; lstSearch.size() > 0;) {


      // 获取队列第一个顶点的索引
      Integer currIndex = lstSearch.removeFirst();


      // 获取顶点的邻接顶点的索引
      int nextIndex = getFirstNeighbor(currIndex);


      // 邻接节点存在
      for (; -1 != nextIndex;) {


        // 如果邻接顶点没有被访问过
        if (!isVisited[nextIndex]) {
          lstSearch.add(nextIndex);
          isVisited[nextIndex] = true;
          System.out.print(lstVertex.get(nextIndex) + " -> ");
        }
        // 获取下一个顶点的索引进行处理
        nextIndex = getNextNeighbor(currIndex, nextIndex);
      }
    }
  }


}

（2）创建一个测试类 Test ：

package com.xiaoer.figure;


public class Test {


  public static void main(String[] args) {
    MyChart myChart = MyChart.createChart(8);
        System.out.println("深度优先遍历: ");
        myChart.bfs();
  }


}

程序运行一下，日志打印如下所示；