4 图的遍历

  图的遍历分为深度优先遍历和广度优先遍历两种。

4.1 深度优先遍历

  深度优先遍历（Depth First Search），也称为深度优先搜索，简称DFS，深度优先遍历，是指从某一个顶点开始，按照一定的规则，访问并记录下一个未访问顶点。对于非连通图，则是按连通分量，采用同一规则进行深度优先遍历的方式，以以下图为例：

  我们使用visited[vertexSize]来记录已访问的顶点，先从A开始，并把A加入到visited中，访问规则是“下一个访问的顶点是最右手边的那个顶点”，注意，图上的小人是面向我们，从上往下走的，此时visited = {A}：

  接下来，依附于顶点A的边有(A,B)、(A,F)，小人右手边的边是(A,B)，因此延着(A,B)走，visited = {A, B}:

  依附于顶点B的边有(B,C)、(B,I)、(B,G)，小人右手边且没被走过的边是(B,C)，于是延着边(B,C)走，visited = {A, B, C}：

  按照这个规则走，走到F时，visited = {A, B, C, D, E, F}：

  这时，小人的右手边有几条路，从右至左依次是(F,A)、(F,G)、(F、E)，但顶点A在visited中，表示顶点A已经被访问过了，所以排除(F,A)，延着(F,G)走，visited = {A, B, C, D, E, F, G}：

  这时，相对于顶点G，小人可走的路从右到左依次是(G,B)、(G,D)、(G,H），B和D已经在visited中，因此跳过，延着(G,H)走，visited = {A, B, C, D, E, F, G, H}：

  这是，相对于顶点H，小人可走的路从右到左依次是(H,D)、(H、E)，但D和E都在visited中了，这时，让小人延原路返回，即延着(H,G)走：

  但相对于顶点G，可走的路(G,B)、(G,D)和(G,H)三条路对应的顶点B、D、H也都在visited中了，无路可走了，继续原路返回，到顶点F，仍然无路可走，继续返回E，仍无路可走，继续返回D：

  这时，发现了(D,I)这条路还没走过，于是延着(D,I)走，visited = {A, B, C, D, E, F, G, H, I}：

  又无路可走了，于是原路返回，直到返回顶点A，也就是开始的那个顶点，表示图已遍历完。

  再来总结一下深度遍历优先的过程：

  (1) 先定一个规则，比如“延着依附于当前顶点中，最左侧的，未被访问的边进行迭代”；

  (2) 从某一个顶点开始按定义的规则迭代；

  (3) 若有符合规则的边，则继续往下迭代，若无符合规则的边，则一步一步原路返回，查找可迭代的边；

  (4) 当原路返回到最开始的那个顶点时，迭代完毕；

  实际上整体上是一个递归调度的过程，主要就是找到“下一条边”。

  注意，深度优先遍历的规则并不是固定不变的，只要最终结果遵循“按一定规则，逐步访问结点的下一个邻边”即可。

4.1.1 邻接矩阵的深度优先遍历

  我们举几个例子：

  对这些图使用深度优先遍历时，找“下一条未被访问边”的方式是：

  (1) 从第一个顶点开始，访问arc[0][1]、arc[0][2]…arc[0][n]，找到第一个未被访问的边，边的判断是，如果为图，则值为1表示存在边，如果为网，则值不为无穷大且arc[i][j]中i不等于j表示存在边；

  (2) 找到这个边后，访问它，假设这个边为arc[0][x]；

  (3) 然后继续访问arc[x]，找到x的未被访问的边，即递归第(1)、(2)步，直到所有关联的边都访问完；

  (4) 若此时，结点还未迭代完，则从第二个“未被访问的顶点”开始，继续迭代；

  因此如上无向图的遍历过程如下所示：

  过程为：

  (0) iterate C；

  (1) 遍历arc[0][j]，寻找C相关的顶点，找到(C,D)，visit C，visit D；

  (2) 遍历arc[1][j]，寻找D相关的顶点，找到(D,C)，两个顶点都被访问过，跳过；

  (3) 找到(D,A)，visit A；

  (4) 遍历arc[2][j]，寻找A相关的顶点，找到(A,C)，两个顶点都被访问过，跳过；

  (5) 找到(A,D)，两个顶点都被访问过，跳过；

  (6) 找到(A,B)，visit B；

  (7) 遍历arc[3][j]，寻找B相关的顶点，找到(B,C)，两个顶点都被访问过，跳过；

  (8) 找到(B,D)，值为0，不相关，跳过；

  (9) 找到(B,A)，两个顶点都被访问过，跳过；

  (10) 找到(B,F)，visit F；

  (11) 遍历arc[4][j]，寻找F相关的顶点，找到(F,C)，值为0，不相关，跳过；

  (12) 找到(F,D)，值为0，不相关，跳过；

  (13) 找到(F,A)，值为0，不相关，跳过；

  (14) 找到(F,B)，两个顶点都被访问过，跳过；

  (15) 找到(F,E)，visit E，此时所有顶点均访问完毕，结束；

  如上有向网的遍历过程如下所示：

  过程为：

  (0) iterate E；

  (1) 迭代arc[0][j]，寻找E指向的顶点，找到<E,F>，visit E，然后发现数组值为无穷大，不相关，跳过；

  (2) 找到<E,C>，值为无穷大，不相关，跳过；

  (3) 找到<E,A>，visit A；

  (4) 迭代arc[3][j]，寻找A指向的顶点，找到<A,E>，值为无穷大，不相关，跳过；

  (5) 找到<A,F>，值为无穷大，不相关，跳过；

  (6) 找到<A,C>，值为无穷大，不相关，跳过；

  (7) 找到<A,B>，值为无穷大，不相关，跳过；

  (8) 找到<A,D>，visit D；

  (9) 迭代arc[5][j]，寻找D指向的顶点，找到<D,E>，值为无穷大，不相关，跳过；

  (10) 找到<D,F>，visit F；

  (11) 迭代arc[1][j]，寻找F指向的顶点，找到<F,E>，值为无穷大，不相关，跳过；

  (12) 找到<F,C>，值为无穷大，不相关，跳过；

  (13) 找到<F,A>，值为无穷大，不相关，跳过；

  (14) 找到<F,B>，值为无穷大，不相关，跳过；

  (15) 找到<F,D>，值为无穷大，不相关，跳过；

  (16) F处理完毕，没有相关的顶点，于是回退一步，到D，继续迭代arc[5][j]，找到<D,C>，visit C；

  (17) 迭代arc[2][j]，寻找C指向的顶点，找到<C,E>，E已被访问，跳过；

  (18) 找到<C,F>，值为无穷大，不相关，跳过；

  (19) 找到<C,A>，值为无穷大，不相关，跳过；

  (20) 找到<C,B>，visit B，此时所有顶点均访问完毕，结束；

  代码实现如下所示：

/**
 * 对图进行深度优先遍历
 *
 * @author Korbin
 * @date 2023-02-02 17:02:23
 **/
public List<T> deepFirstTraverse() {

    List<T> visitedVertex = new ArrayList<>();
    boolean[] visited = new boolean[vertexNum];

    for (int i = 0; i < vertexNum && visitedVertex.size() < vertexNum; i++) {
        deepFirstTraverse(visitedVertex, visited, i);
    }

    return visitedVertex;

}

/**
 * 对图进行深度迭代
 *
 * @param visitedVertex 迭代结果
 * @param visited       已访问过的顶点
 * @param index         接着要迭代的结点
 * @author Korbin
 * @date 2023-02-02 17:26:43
 **/
public void deepFirstTraverse(List<T> visitedVertex, boolean[] visited, int index) {

    // 取出当前顶点
    if (!visited[index]) {
        // 当前顶点未被访问，才继续
        T ver = vertex[index];
        visitedVertex.add(ver);
        visited[index] = true;
        // 取出当前顶点可走的边
        for (int j = 0; j < arc[index].length && visitedVertex.size() < vertexNum; j++) {

            if (j != index) {
                switch (type) {
                    case UNDIRECTED:
                    case DIRECTED: {
                        // 无向图或有向图，为1且顶点未被访问表示可以走
                        try {
                            int weight = (int) (arc[index][j]);
                            if (weight == 1 && !visited[j]) {
                                // 可以继续往下走
                                deepFirstTraverse(visitedVertex, visited, j);
                            }
                        } catch (NumberFormatException e) {
                            // do nothing
                        }
                        break;
                    }
                    case UNDIRECTED_NETWORK:
                    case DIRECTED_NETWORK: {
                        // 无向图或有向网
                        // 不为infinity，且顶点未被访问
                        if (!arc[index][j].equals(infinity) && !visited[j]) {
                            // 可以继续往下走
                            deepFirstTraverse(visitedVertex, visited, j);
                        }
                        break;
                    }
                }
            }

        }
    }
}

4.1.2 邻接表的深度优先遍历

  考虑如下有向图：

  从第一个顶点开始，打到它未被访问的下一个顶点，寻找的过程是先找firstEdge，如果firstEdge指向的顶点已被访问，则找firstEdge的next，直到找到这个顶点为止；接着访问这个顶点的指向下一个未访问的顶点，寻找方式与第一个顶点相同。

  该邻接表的遍历过程如下所示：

  整体过程为：

  (0) iterate C, visit C；

  (1) 找顶点C相关的顶点，找到(C,D)，visit D；

  (2) 找顶点D相关的顶点，找到(D,C)，两个顶点都被访问过，跳过；

  (3) 继续找顶点D相关的顶点，找到(D,A)，visit A；

  (4) 找顶点A相关的顶点，找到(A,C)，两个顶点都被访问过，跳过；

  (5) 继续找顶点A相关的顶点，找到(A,D)，两个顶点都被访问过，跳过；

  (6) 继续找顶点A相关的顶点，找到(A,B)，visit B；

  (7) 找顶点B相关的顶点，找到(B,C)，两个顶点都被访问过，跳过；

  (8) 继续找顶点B相关的顶点，找到(B,A)，两个顶点都被访问过，跳过；

  (9) 继续找顶点B相关的顶点，找到(B,F)，visit F；

  (10) 找顶点F相关的顶点，找到(F,B)，两个顶点都被访问过，跳过；

  (11) 继续找顶点F相关的顶点，找到(F,E)，visit E，此时所有顶点都访问完毕，结束；

  相应地，有向图的邻接表遍历过程如下所示：

  即：

  (0) iterate C，visit C；

  (1) 找顶点C指向的顶点，找到<C,B>，visit B；

  (2) 找顶点B指向的顶点，找到<B,A>，visit A；

  (3) 找顶点A指向的顶点，找到<A,D>，visit D；

  (4) 找顶点D指向的顶点，找到<D,C>，两个顶点都被访问过，跳过；

  (5) 继续找顶点D指向的顶点，找到<D,B>，两个顶点都被访问过，跳过；

  (6) 继续找顶点D指向的顶点，找到<D,F>，visit F；F没有指向的顶点，回退到D；继续找顶点D指向的顶点，D所有指向的顶点都已访问，回退到B；继续找顶点B指向的顶点，B所有指向的顶点都已被访问，回退到C；

  (7) 继续找顶点C指向的顶点，找到<C,E>，visit E，此时所有顶点访问完毕，结束；

  除了邻接表外，还有一种逆邻接表，逆邻接表使用的遍历方法与邻接表不同，因为边集数组中保存的是每个顶点被指向的信息，如下：

  逆邻接表的查找下一个未访问顶点的过程，是“遍历边集数组，找到firstEdge或nextEdge的为当前顶点的边集数组结点，这个边集数组元素关联的第一个未被访问的顶点数组元素，就是要找的下一个顶点”，如上逆邻接表的遍历过程如下：

  (1) 从第一个顶点C开始迭代，将它加入访问列表，visit C；

  (2) 迭代所有边集数组，找到C指向的顶点，因为C已被访问，因此忽略它，先看D，只有边<A,D>，与顶点C不相关，跳过；

  (3) 看顶点A，第一条边<B,A>，与顶点C不相关，跳过；

  (4) 继续看顶点A，第二条边<E,A>，与顶点C不相关，跳过；

  (5) A的边看完了，看B的边，第一条边<C,B>，找到顶点B是C指向的顶点，且由于是按下标从小到大迭代的，因此它一定是C指向的，且下标最小的顶点，因此，visit B；

  (6) 接下来看顶点B指向的顶点，首先是顶点C，因为已访问过，因此忽略，然后是顶点D，有边<A,D>，与顶点B不相关，跳过；

  (7) 然后看顶点A，有边<B,A>，A是顶点B指向的顶点，因此visit A；

  (8) 接下来看顶点A指点的顶点，顶点C已被访问，仍然跳过，然后是顶点D，打到边<A,D>，符合要求，因此，visit D；

  (9) 接下来看顶点D指向的顶点，前面的几个顶点C、D、A、B都已被访问过，跳过，看顶点F，有边<D,F>，符合要求，因此，visit F；

  (10) 接下来看顶点F指向的顶点，前面的几个顶点C、D、A、B、F都已被访问，跳过，看顶点E，有边<C,E>，与顶点F不相关，跳过；

  (11) 这时，所有顶点都迭代完毕，但仍未访问到所有顶点，因此回到第(1)步，继续迭代顶点，C已迭代过，于是看顶点D，顶点D已被访问，跳过；

  (12) 继续，迭代顶点A，已被访问，跳过；

  (13) 继续，迭代顶点B，已被访问，跳过；

  (14) 继续，迭代顶点F，已被访问，跳过；

  (15) 继续，迭代顶点E，未被访问，因此，visit E，此时，所有顶点都访问完毕，遍历结束；

  代码实现如下所示：

/**
 * 对图进行深度优先遍历
 *
 * @author Korbin
 * @date 2023-02-02 19:59:26
 **/
public List<T> deepFirstTraverse() {
    List<T> vertexList = new ArrayList<>();
    boolean[] visited = new boolean[vertexNum];

    // 对于邻接表，从第一个顶点开始处理，先处理firstEdge
    for (int i = 0; i < vertexNum && vertexList.size() < vertexNum; i++) {
        if (!visited[i]) {

            System.out.println("iterate " + vertexes[i].getVertex());

            VertexNode<T, W> vertexNode = vertexes[i];
            vertexList.add(vertexNode.getVertex());
            visited[i] = true;

            if (reverseAdjacency) {
                deepFirstTraverse(vertexList, visited, i);
            } else {
                deepFirstTraverse(vertexList, visited, vertexNode);
            }

        }

    }

    return vertexList;
}

/**
 * 对使用逆邻接表存储的图进行深度优先遍历
 *
 * @param vertexList 遍历结果
 * @param visited    访问列表
 * @param index      当前遍历的下标
 * @author Korbin
 * @date 2023-02-06 18:13:34
 **/
public void deepFirstTraverse(List<T> vertexList, boolean[] visited, int index) {

    int minRefIndex = -1;

    // 找到index指向的下标最小的未访问的顶点
    boolean got = false;
    for (int i = 0; i < vertexNum && vertexList.size() < vertexNum && !got; i++) {
        if (!visited[i]) {
            VertexNode<T, W> vertexNode = vertexes[i];

            EdgeNode<W> edgeNode = vertexNode.getFirstEdge();
            while (null != edgeNode && vertexList.size() < vertexNum) {
                int edgeIndex = edgeNode.getIndex();

                System.out.format("check %s-%s\r\n", vertexes[edgeIndex].getVertex(), vertexes[i].getVertex());

                if (edgeIndex == index) {
                    minRefIndex = i;
                    got = true;
                    break;
                }
                edgeNode = edgeNode.getNext();
            }
        }
    }

    if (minRefIndex != -1) {
        if (!visited[minRefIndex]) {
            // 访问这个顶点
            visited[minRefIndex] = true;
            vertexList.add(vertexes[minRefIndex].getVertex());

            System.out.println("in " + vertexes[minRefIndex].getVertex());

            // 再访问这个顶点指向的顶点
            deepFirstTraverse(vertexList, visited, minRefIndex);
        }
    }
}

/**
 * 对使用邻接表存储的图进行深度优先遍历
 *
 * @param vertexList 遍历结果
 * @param visited    已访问的顶点
 * @param vertexNode 正在访问的顶点
 * @author Korbin
 * @date 2023-02-03 20:26:22
 **/
public void deepFirstTraverse(List<T> vertexList, boolean[] visited, VertexNode<T, W> vertexNode) {
    EdgeNode<W> firstEdge = vertexNode.getFirstEdge();
    while (null != firstEdge && vertexList.size() < vertexNum) {

        System.out.format("check %s-%s\r\n", vertexNode.getVertex(), vertexes[firstEdge.getIndex()].getVertex());

        int index = firstEdge.getIndex();
        if (!visited[index]) {
            // 把它加入到遍历结果中，然后递归处理它对应的顶点
            VertexNode<T, W> nextNode = vertexes[index];
            vertexList.add(nextNode.getVertex());
            visited[index] = true;

            deepFirstTraverse(vertexList, visited, nextNode);
        }
        // 取下一个edge
        firstEdge = firstEdge.getNext();

    }
}

4.1.3 十字链表的深度优先遍历

  十字链表是在邻接表上的进一步优化，因此十字链表的深度优先遍历方式与邻接表类似，邻接表是处理firstEdge，十字链表处理的是firstOut和nextHead，因为firstOut就等于邻接表（非逆邻接表）的firstEdge，而nextHead相关于邻接表的EdgeNode中的next，大致逻辑为：

  (1) 从第一个顶点开始处理，按如下规则：

    1) 如果顶点X未被访问，则访问它；

    2) 找到顶点X的指向的下一个未被访问的顶点，我们知道，首先是firstOut，然后是firstOut之后弧结点的nextHead；

    3) 找到这个顶点后，访问它，然后递归1)、2)步；

  (2) 继续迭代顶点列表中的其他顶点，若还有未访问的顶点，则按(1)的规则处理，直到所有顶点处理完毕；

  以下面的十字链表为例：

  下图展示了它的深度优先遍历过程：

  (0) 先忽略所有firstIn相关的线，然后iterate E，visit E；

  (1) 找到E指向的顶点，找到<E,A>，visit A；

  (2) 找到A指向的顶点，找到<A,D>，visit D；

  (3) 找到D指向的顶点，找到<D,F>，visit F；F没有指向的顶点，因此回退到D；

  (4) 找到D指向的顶点，找到<D,C>，visit C;

  (5) 找到C指向的顶点，找到<C,E>，两个顶点都已被访问，跳过；

  (6) 继续找到C指向的顶点<C,B>，visit B，此时所有顶点都已被访问，结束；

  代码如下所示：

/**
 * 对图进行深度优先遍历
 *
 * @author Korbin
 * @date 2023-02-02 19:59:26
 **/
public List<T> deepFirstTraverse() {
    List<T> vertexList = new ArrayList<>();
    boolean[] visited = new boolean[vertexNum];

    // 对于邻接表，从第一个顶点开始处理，先处理firstEdge
    for (int i = 0; i < vertexNum && vertexList.size() < vertexNum; i++) {
        if (!visited[i]) {
            AcrossLinkVertexNode<T, W> vertexNode = vertexes[i];
            vertexList.add(vertexNode.getVertex());
            visited[i] = true;

            deepFirstTraverse(vertexList, visited, vertexNode);

        }

    }
    return vertexList;
}

/**
 * 对图进行深度优先遍历
 *
 * @param vertexList 遍历结果
 * @param visited    已访问于列表
 * @param vertexNode 待处理的顶点
 * @author Korbin
 * @date 2023-02-03 19:33:32
 **/
private void deepFirstTraverse(List<T> vertexList, boolean[] visited, AcrossLinkVertexNode<T, W> vertexNode) {

    AcrossLinkEdgeNode<W> firstEdge = vertexNode.getFirstOut();
    int nextIndex = -1;
    while (null != firstEdge && vertexList.size() < vertexNum) {
        // 指向的顶点下标为headIndex
        int index = firstEdge.getHeadIndex();

        if (!visited[index]) {
            vertexList.add(vertexes[index].getVertex());
            visited[index] = true;
            nextIndex = index;

            // 递归处理下一个顶点的邻边
            deepFirstTraverse(vertexList, visited, vertexes[nextIndex]);
        }
        firstEdge = firstEdge.getNextHead();
    }
}

4.1.4 邻接多重表的深度优先遍历

  考虑如下邻接多重表：

  第一个顶点是C，它有三条关联的边，分别是(C,A)、(C,B)和(C,D)，我们把规则定为，下一个未访问的邻边是在顶点数组中下标最小，且未访问的那条边，这个定义与邻接多重表的存储结构相同，邻接多重表的存储设计是“firstEdge指向第一条边，iLink指向下一条边（下一条边的jVex必须为当前顶点），下一条边的jLink指向下下一条边（并不要求jVex为当前顶点），下下一条边的jLink指向下下一条边（并不要求jVex为当前顶点）,依此类推”，因此邻接多重表深度优先遍历的过程是：

  (1) 从第一个顶点X开始，找到这个顶点下一条未被访问的边(X,Y)：

    1) 若能找到Y，则访问Y，并查找Y的下一条未被访问的边；

    2) 若Y不存在，则原路返回，走上一个顶点的未被访问的边；

  (2) 递归执行第(1)步，直到找不到下一条未被访问的边时，继续对第二个顶点进行处理，直到所有顶点处理完毕。

  如下为该邻接多重表的深度优先遍历过程：

  过程为：

  (0) iterate C，visit C；

  (1) 找C关联的顶点，找到(C,D)，visit D；

  (2) 找D关联的顶点，找到(D,A)，visit A；

  (3) 找A关联的顶点，找到(A,C)，两个顶点都已访问，跳过；

  (4) 继续找A关联的顶点，找到(D,A)，两个顶点都已访问，跳过；

  (5) 继续找A关联的顶点，找到(A,B)，visit B；

  (6) 找B关联的顶点，找到(B,C)，两个顶点都已访问，跳过；

  (7) 继续找B关联的顶点，找到(A,B)，两个顶点都已访问，跳过；

  (8) 继续找B关联的顶点，找到(F,B)，visit F；

  (9) 找F关联的顶点，找到(F,B)，两个顶点都已访问，跳过；

  (10) 继续找F关联的顶点，找到(E,F)，visit E，所有顶点都已访问，结束；

  实现代码如下所示：

/**
 * 对图进行深度优先遍历
 *
 * @return 遍历结果
 * @author Korbin
 * @date 2023-02-03 17:09:46
 **/
public List<T> deepFirstTraverse() {

    List<T> vertexList = new ArrayList<>();
    boolean[] visited = new boolean[vertexNum];

    for (int i = 0; i < vertexNum && vertexList.size() < vertexNum; i++) {
        // 从第1个顶点开始找
        if (!visited[i]) {

            AdjacencyMultiVertexNode<T, W> vertexNode = vertexes[i];
            vertexList.add(vertexNode.getVertex());
            visited[i] = true;

            deepFirstTraverse(vertexList, visited, vertexNode);
        }

    }

    return vertexList;

}

/**
 * 对图进行深度优先遍历
 *
 * @param vertexList 遍历结果
 * @param visited    顶点是否已被访问
 * @param vertexNode 待迭代的顶点
 * @author Korbin
 * @date 2023-02-03 17:44:43
 **/
public void deepFirstTraverse(List<T> vertexList, boolean[] visited, AdjacencyMultiVertexNode<T, W> vertexNode) {
    AdjacencyMultiEdgeNode<W> firstEdge = vertexNode.getFirstEdge();
    if (null != firstEdge) {
        // firstEdge的关联顶点下标是jVex
        int index = firstEdge.getJVex();
        int myIndex = firstEdge.getIVex();

        if (!visited[index]) {
            // 未访问
            AdjacencyMultiVertexNode<T, W> nextVertexNode = vertexes[index];
            vertexList.add(nextVertexNode.getVertex());
            visited[index] = true;

            // 然后处理index对应的顶点，找它的下一个未访问的邻边
            deepFirstTraverse(vertexList, visited, nextVertexNode);
        } else {
            // 已访问
            // 下一个相关边是firstEdge的iLink
            AdjacencyMultiEdgeNode<W> nextEdge = firstEdge.getILink();
            if (null != nextEdge) {
                // 这个相关边的关联顶点是iVex
                index = nextEdge.getIVex();

                if (!visited[index]) {
                    // 未访问
                    AdjacencyMultiVertexNode<T, W> nextVertexNode = vertexes[index];
                    vertexList.add(nextVertexNode.getVertex());
                    visited[index] = true;

                    // 然后处理index对应的顶点，找它的下一个未访问的邻边
                    deepFirstTraverse(vertexList, visited, nextVertexNode);
                } else {
                    // 已访问
                    // 下一条，以及下下条等，相关边都是jLink
                    nextEdge = nextEdge.getJLink();
                    while (null != nextEdge && vertexList.size() < vertexNum) {
                        // 关联顶点可能是iVex，也可能是jVex
                        int iVex = nextEdge.getIVex();
                        int jVex = nextEdge.getJVex();
                        if (iVex == myIndex) {
                            // 关联顶点是JVex
                            if (!visited[jVex]) {
                                AdjacencyMultiVertexNode<T, W> nextVertexNode = vertexes[jVex];
                                vertexList.add(nextVertexNode.getVertex());
                                visited[jVex] = true;

                                // 然后处理index对应的顶点，找它的下一个未访问的邻边
                                deepFirstTraverse(vertexList, visited, nextVertexNode);
                            } else {
                                nextEdge = nextEdge.getJLink();
                            }
                        } else if (jVex == myIndex) {
                            // 关联顶点是IVex
                            if (!visited[iVex]) {
                                AdjacencyMultiVertexNode<T, W> nextVertexNode = vertexes[iVex];
                                vertexList.add(nextVertexNode.getVertex());
                                visited[iVex] = true;

                                // 然后处理index对应的顶点，找它的下一个未访问的邻边
                                deepFirstTraverse(vertexList, visited, nextVertexNode);
                            } else {
                                nextEdge = nextEdge.getILink();
                            }
                        }
                    }
                }
            }
        }
    }

}

4.1.5 边集数组的深度优先遍历

  边集数组存储了每条边的begin、end信息，由于无向图/网和有向图/网不同，无向图/网的begin和end可以是边上的任何一个顶点，因此对于无向图/网和有向图/网的遍历方式不同，但整体方向差不多：从下标最小的那个顶点开始，找每个顶点关联的、未被访问的、下标最小的那个顶点进行访问。

  先看无向图/网：

  从下标最小的那个顶点开始找，即从顶点C开始找，找它的边，有(B,C)、(C,A)和(C,D)，下标最小的关联顶点是D，然后找D的边，有(A,D)、(C,D)，C被访问过了，因此下一个顶点是C，依此类推，整体过程如下：

  整体过程是：

  (0) iterate C；

  (1) 找到C关联的顶点，找到(C,D)，visit C，visit D；

  (2) 找到D关联的顶点，找到(A,D)，visit A；

  (3) 找到A关联的顶点，找到(A,B)，visit B；

  (4) 找到B关联的顶点，找到(B,F)，visit F；

  (5) 找到F关联的顶点，找到(F,E)，visit E，所有顶点访问完毕，结束；

  无向图/网在找“下一个顶点”时，找到的边中，可以begin等于当前顶点，也可以end等于当前顶点，但有向网则不同，只能找end为当前顶点的边，看如下有向图：

  处理过程如下：

  整体过程是：

  (0) iterate E；

  (1) 找E指向的顶点，找到<E,A>，visit E，visit A；

  (2) 找A指向的顶点，找到<A,D>，visit D；

  (3) 找D指向的顶点，找到<D,F>，visit F；F没有指向任何顶点，回退到D；

  (4) 找D指向的顶点，找到<D,C>，visit C；

  (5) 找C指向的顶点，找到<C,B>，visit B，此时，所有顶点访问完毕，结束；

  代码实现如下所示：

/**
 * 对图进行深度优先遍历
 *
 * @return 遍历结果
 * @author Korbin
 * @date 2023-02-06 14:25:42
 **/
public List<T> deepFirstTraverse() {
    List<T> vertexList = new ArrayList<>();
    boolean[] visited = new boolean[vertexNum];
    for (int i = 0; i < vertexNum && vertexList.size() < vertexNum; i++) {
        deepFirstTraverse(vertexList, visited, i);
    }
    return vertexList;
}

/**
 * 对图进行深度优先遍历
 *
 * @param vertexList 遍历结果
 * @param visited    访问记录
 * @param index      待处理的下标
 * @author Korbin
 * @date 2023-02-06 14:25:58
 **/
public void deepFirstTraverse(List<T> vertexList, boolean[] visited, int index) {

    // 找下标为i的顶点关联的边中，关联顶点下标最小且未访问的顶点
    int minReleVertex = -1;
    for (int j = 0; j < arc.length && vertexList.size() < vertexNum; j++) {
        EdgeListEdgeNode<W> edgeNode = arc[j];
        int begin = edgeNode.getBegin();
        int end = edgeNode.getEnd();

        switch (type) {
            case UNDIRECTED:
            case UNDIRECTED_NETWORK: {
                if (begin == index && !visited[end]) {
                    if (minReleVertex == -1 || minReleVertex > end) {
                        minReleVertex = end;
                    }
                } else if (end == index && !visited[begin]) {
                    if (minReleVertex == -1 || minReleVertex > begin) {
                        minReleVertex = begin;
                    }
                }
                break;
            }
            case DIRECTED:
            case DIRECTED_NETWORK: {
                if (begin == index && !visited[end]) {
                    if (minReleVertex == -1 || minReleVertex > end) {
                        minReleVertex = end;
                    }
                }
                break;
            }
        }

    }

    if (!visited[index]) {
        // 访问该顶点
        visited[index] = true;
        vertexList.add(vertex[index]);
    }

    if (minReleVertex != -1 && !visited[minReleVertex]) {
        // 访问该顶点的下标最小的关联顶点
        visited[minReleVertex] = true;
        vertexList.add(vertex[minReleVertex]);

        // 接下来，访问关联顶点的“下标最小的关联顶点”
        deepFirstTraverse(vertexList, visited, minReleVertex);
		
		// 处理完毕后，应继续处理本顶点，即“下一个顶点没有关联的顶点，因此回退一步”
		deepFirstTraverse(vertexList, visited, index);
    }

}

4.2 广度优先遍历

  广度优先遍历（Breadth First Search），又称为广度优先搜索，简称BFS，广度优先遍历有点类似于树的层序遍历。

4.2.1 邻接矩阵的广度优先遍历

  考虑如下无向图：

  广度优先遍历的方法是：从下标最小的顶点C开始，访问C，然后找到它的下一层，访问它的下一层，然后找到下一层的下一层，访问它们，依此类推。

  在无向图中我们这边实现：

  (0) 我们先建一个队列用于辅助；

  (1) 从顶点C开始，把它的下标加入队列，此时队列里面只有C；

  (2) 从队列中取出队头的数据，即C的下标0，访问C，然后迭代arc[0][j]，weight为1的依次加入队列，此时队列从尾到头依次是B、A、D，已访问列表里有{C}；

  (3) 从队列中取出队头的数据，即D的下标1，访问D，然后迭代arc[1][j]，weight为1且未被访问的依次加入队列，此时队列从尾到头依次是A、B、A，已访问列表里有{C, D}；

  (4) 从队列中取出队头的数据，即A的下标2，访问A，然后迭代arc[2][j]，weight为1且未被访问的依次加入队列，此时队列从尾到头依次是B、A、B，已访问列表里有{C, D, A}；

  (5) 从队列中取出队头的数据，即B的下标3，访问B，然后迭代arc[3][j]，weight为1且未被访问的依次加入队列，此时队列从尾到头依次是F、B、A，已访问列表里有{C, D, A, B}；

  (6) 从队列中取出队头的数据，即A的下标2，发现A已被访问，跳过，此时队列从尾到头依次是F、B，已访问列表里有{C, D, A, B}；

  (7) 从队列中取出队头的数据，即B的下标3，发现B已被访问，跳过，此时队列从尾到头依次是F，已访问列表里有{C, D, A, B}；

  (8) 从队列中取出队头的数据，即F的下标4，访问F，然后迭代arc[4][j]，weight为1且未被访问的依次加入队列，此时队列从尾到头依次是E，已访问列表里有{C, D, A, B, F}；

  (9) 从队列中取出队头的数据，即E的下标5，访问E，这时发现所有顶点均已访问完毕，结束遍历，得到结果{C, D, A, B, F, E}；

  有向图/网的实现类似，考虑如下有向网：

  遍历过程如下所示：

  (1) 仍然使用一个辅助队列，用于存储顶点下标，从下标为0的顶点开始迭代，先将它入队，此时队列里面只有E；

  (2) 从队列中取出队头数据，即E的下标0，访问它，迭代arc[0][j]，取出相关边，有<E,A>，将A插入队列，此时队列里面只有A，已访问顶点列表为{E}；

  (3) 从队列中取出队头数据，即A的下标3，访问它，迭代arc[3][j]，取出相关边，有<A,D>，将D插入队列，此时队列里面只有D，已访问顶点列表为{E, A}；

  (4) 从队列中取出队头数据，即D的下标5，访问它，迭代arc[5][j]，取出相关边，有<D,F>、<D,C>、<D,B>，将F、C、B依次插入队列，此时队列从队尾到队头依次是B、C、F，已访问顶点列表为{E, A, D}；

  (5) 从队列中取出队头数据，即F的下标1，访问它，迭代arc[1][j]，取出相关边，没有，不进行处理，此时队列从队尾到队头依次是B、C，已访问顶点列表为{E, A, D, F}；

  (6) 从队列中取出队头数据，即C的下标2，访问它，迭代arc[2][j]，取出相关边，有<C,E>、<C,B>，因为顶点E已被访问，因此忽略它，把B加入到队列，此时队列从队尾到队头依次是B、B，已访问顶点列表为{E, A, D, F, C}；

  (7) 从队列中取出队头数据，即B的下标4，访问它，发现所有顶点已访问完毕，遍历结束，得到结果{E, A, D, F, C, B}；

  代码实现如下所示：

/**
 * 对图进行广度优先遍历
 *
 * @return 遍历结果
 * @author Korbin
 * @date 2023-02-06 19:33:16
 **/
public List<T> breadthFirstTraverse() {

    List<T> vertexList = new ArrayList<>();
    boolean[] visited = new boolean[vertexNum];

    LinkQueue<Integer> queue = new LinkQueue<>();
    queue.init();

    for (int i = 0; i < vertexNum && vertexList.size() < vertexNum; i++) {

        if (!visited[i]) {
            // 入队列
            LinkListNode<Integer> node = new LinkListNode<>();
            node.setData(i);
            queue.insert(node);

            System.out.println("iterate " + vertex[i]);

            while (!queue.isEmpty() && vertexList.size() < vertexNum) {
                // 一个个取出来访问，并把它们的下一层放入队列
                node = queue.delete();
                int index = node.getData();

                if (!visited[index]) {

                    vertexList.add(vertex[index]);
                    visited[index] = true;
                    System.out.println("in " + vertex[index]);

                    for (int j = 0; j < vertexNum && vertexList.size() < vertexNum; j++) {
                        if (j != index && !visited[j]) {

                            boolean canInsert = false;

                            switch (type) {
                                case UNDIRECTED:
                                case DIRECTED: {
                                    // 无向图和有向图，weight为1表示顶点相关
                                    try {
                                        int weight = (int) arc[index][j];
                                        if (weight == 1) {
                                            canInsert = true;
                                        }
                                    } catch (NumberFormatException e) {
                                        // do nothing
                                    }

                                    break;
                                }
                                case UNDIRECTED_NETWORK:
                                case DIRECTED_NETWORK: {
                                    // 无向网和有向网，weight不为infinity表示顶点相关
                                    if (!arc[index][j].equals(infinity)) {
                                        canInsert = true;
                                    }
                                }
                            }

                            if (canInsert) {
                                // 把下一层入队
                                node = new LinkListNode<>();
                                node.setData(j);
                                queue.insert(node);

                                System.out.println("in queue " + vertex[j]);
                            }
                        }
                    }
                }

            }
        }

    }
    return vertexList;
}

4.2.2 邻接表的广度优先遍历

  与邻接矩阵相同，邻接表的广度优先遍历也借助队列实现，其中，逆邻接表的实现会更为复杂：

/**
 * 对图进行广度优先遍历
 *
 * @return 遍历结果
 * @author Korbin
 * @date 2023-02-07 08:38:46
 **/
public List<T> breadthFirstTraverse() {

    List<T> vertexList = new ArrayList<>();

    boolean[] visited = new boolean[vertexNum];

    LinkQueue<Integer> queue = new LinkQueue<>();
    queue.init();

    for (int i = 0; i < vertexNum && vertexList.size() < vertexNum; i++) {

        System.out.println("iterate " + vertexes[i].getVertex());

        if (!visited[i]) {

            LinkListNode<Integer> node = new LinkListNode<>();
            node.setData(i);
            queue.insert(node);

            System.out.println("insert " + vertexes[i].getVertex());

            while (!queue.isEmpty() && vertexList.size() < vertexNum) {

                // 出队列
                node = queue.delete();
                System.out.println("get " + vertexes[node.getData()].getVertex());

                int index = node.getData();
                VertexNode<T, W> vertexNode = vertexes[index];
                // 访问该顶点
                if (!visited[index]) {
                    vertexList.add(vertexNode.getVertex());
                    visited[index] = true;

                    System.out.println("visit " + vertexNode.getVertex());

                    if (!reverseAdjacency) {
                        //  邻接表
                        // 把指向的顶点一一入队
                        EdgeNode<W> edge = vertexNode.getFirstEdge();
                        while (edge != null && vertexList.size() < vertexNum) {
                            index = edge.getIndex();
                            if (!visited[index]) {

                                System.out.println("insert " + vertexes[index].getVertex());

                                LinkListNode<Integer> childNode = new LinkListNode<>();
                                childNode.setData(index);
                                queue.insert(childNode);
                            }
                            edge = edge.getNext();
                        }
                    } else {
                        // 逆邻表
                        // 把指向的顶点一一入队
                        for (int j = 0; j < vertexNum && vertexList.size() < vertexNum; j++) {
                            if (j != index && !visited[j]) {
                                VertexNode<T, W> tmpVertex = vertexes[j];
                                EdgeNode<W> tmpEdge = tmpVertex.getFirstEdge();
                                while (null != tmpEdge && vertexList.size() < vertexNum) {
                                    if (tmpEdge.getIndex() == index) {
                                        // 入队

                                        System.out.println(tmpEdge.getIndex() + "=======" + index + "=======" + j);

                                        System.out.println("insert " + vertexes[j].getVertex());

                                        LinkListNode<Integer> childNode = new LinkListNode<>();
                                        childNode.setData(j);
                                        queue.insert(childNode);
                                        break;
                                    }
                                    tmpEdge = tmpEdge.getNext();
                                }
                            }
                        }
                    }

                }

            }

        }

    }

    return vertexList;
}

4.2.3 十字链表的广度优先遍历

  十字链表的实现与邻接表的实现相同：

/**
 * 对图进行广度优先遍历
 *
 * @return 遍历结果
 * @author Korbin
 * @date 2023-02-07 09:56:29
 **/
public List<T> breadthFirstTraverse() {

    List<T> vertexList = new ArrayList<>();
    boolean[] visited = new boolean[vertexNum];

    LinkQueue<Integer> queue = new LinkQueue<>();
    queue.init();

    for (int i = 0; i < vertexNum && vertexList.size() < vertexNum; i++) {

        System.out.println("iterate " + vertexes[i].getVertex());

        if (!visited[i]) {

            LinkListNode<Integer> node = new LinkListNode<>();
            node.setData(i);
            queue.insert(node);

            System.out.println("insert " + vertexes[i].getVertex());

            while (!queue.isEmpty() && vertexList.size() < vertexNum) {

                // 出队列
                node = queue.delete();
                System.out.println("get " + vertexes[node.getData()].getVertex());

                int index = node.getData();
                AcrossLinkVertexNode<T, W> vertexNode = vertexes[index];
                // 访问该顶点
                if (!visited[index]) {
                    vertexList.add(vertexNode.getVertex());
                    visited[index] = true;

                    System.out.println("visit " + vertexNode.getVertex());

                    //  邻接表
                    // 把指向的顶点一一入队
                    AcrossLinkEdgeNode<W> edge = vertexNode.getFirstOut();
                    while (edge != null && vertexList.size() < vertexNum) {
                        index = edge.getHeadIndex();
                        if (!visited[index]) {

                            System.out.println("insert " + vertexes[index].getVertex());

                            LinkListNode<Integer> childNode = new LinkListNode<>();
                            childNode.setData(index);
                            queue.insert(childNode);
                        }
                        edge = edge.getNextHead();
                    }

                }

            }

        }

    }

    return vertexList;

}

4.2.4 邻接多重表的广度优先遍历

  上文有提到如何在邻接多重表中寻找关联的顶点，在进行广度遍历时，同样借助队列实现：

/**
 * 对图进行广度优先遍历
 *
 * @return 遍历结果
 * @author Korbin
 * @date 2023-02-07 10:03:26
 **/
public List<T> breadthFirstTraverse() {

    List<T> vertexList = new ArrayList<>();
    boolean[] visited = new boolean[vertexNum];

    LinkQueue<Integer> queue = new LinkQueue<>();
    queue.init();

    for (int i = 0; i < vertexNum && vertexList.size() < vertexNum; i++) {

        if (!visited[i]) {

            System.out.println("iterate " + vertexes[i].getVertex());

            // 入队
            LinkListNode<Integer> node = new LinkListNode<>();
            node.setData(i);
            queue.insert(node);
            System.out.println("insert " + vertexes[i].getVertex());

            while (!queue.isEmpty() && vertexList.size() < vertexNum) {
                // 从队列中取出
                int index = queue.delete().getData();
                System.out.println("get " + vertexes[index].getVertex());

                if (!visited[index]) {

                    // 访问它
                    AdjacencyMultiVertexNode<T, W> vertexNode = vertexes[index];
                    vertexList.add(vertexNode.getVertex());
                    visited[index] = true;
                    System.out.println("visit " + vertexNode.getVertex());

                    // 取index关联的顶点
                    AdjacencyMultiEdgeNode<W> firstEdge = vertexNode.getFirstEdge();
                    if (null != firstEdge) {
                        int childIndex = firstEdge.getJVex();

                        if (!visited[childIndex]) {
                            // 相关顶点入队
                            LinkListNode<Integer> childNode = new LinkListNode<>();
                            childNode.setData(childIndex);
                            queue.insert(childNode);
                            System.out.println("insert " + vertexes[childIndex].getVertex());

                        }

                        AdjacencyMultiEdgeNode<W> edgeNode = firstEdge.getILink();
                        while (null != edgeNode && vertexList.size() < vertexNum) {

                            // 可能是iVex等于当前顶点，也可能是jVex等于当前顶点
                            int iVex = edgeNode.getIVex();
                            int jVex = edgeNode.getJVex();
                            if (iVex == index && !visited[jVex]) {
                                // 相关顶点是jVex
                                LinkListNode<Integer> childNode = new LinkListNode<>();
                                childNode.setData(jVex);
                                queue.insert(childNode);
                                System.out.println("insert " + vertexes[jVex].getVertex());
                            } else if (jVex == index && !visited[iVex]) {
                                // 相关顶点是iVex
                                LinkListNode<Integer> childNode = new LinkListNode<>();
                                childNode.setData(iVex);
                                queue.insert(childNode);
                                System.out.println("insert " + vertexes[iVex].getVertex());
                            }

                            edgeNode = edgeNode.getJLink();
                        }
                    }

                }
            }

        }

    }

    return vertexList;
}

4.2.5 边集数组的广度优先遍历

  边集数组仍然需要多次迭代边集数组，才能找到相关的顶点：

/**
 * 对图进行广度优先遍历
 *
 * @return 遍历结果
 * @author Korbin
 * @date 2023-02-07 10:30:36
 **/
public List<T> breadthFirstTraverse() {

    List<T> vertexList = new ArrayList<>();
    boolean[] visited = new boolean[vertexNum];

    LinkQueue<Integer> queue = new LinkQueue<>();
    queue.init();

    boolean[] visitedArc = new boolean[edgeNum];

    for (int i = 0; i < vertexNum && vertexList.size() < vertexNum; i++) {

        if (!visited[i]) {

            System.out.println("iterate " + vertex[i]);

            // 入队
            LinkListNode<Integer> node = new LinkListNode<>();
            node.setData(i);
            queue.insert(node);
            System.out.println("insert " + vertex[i]);

            while (!queue.isEmpty() && vertexList.size() < vertexNum) {

                // 取出
                int index = queue.delete().getData();
                System.out.println("get " + vertex[index]);

                if (!visited[index]) {
                    // 访问它
                    vertexList.add(vertex[index]);
                    visited[index] = true;
                    System.out.println("visit " + vertex[index]);

                    // 找它相关的顶点或指向的顶点

                    switch (type) {
                        case UNDIRECTED:
                        case UNDIRECTED_NETWORK: {
                            // 无向图/网
                            for (int j = 0; j < edgeNum && vertexList.size() < vertexNum; j++) {
                                if (!visitedArc[j]) {

                                    System.out.println("iterate arc " + j);

                                    EdgeListEdgeNode<W> edge = arc[j];
                                    int begin = edge.getBegin();
                                    int end = edge.getEnd();

                                    if (begin == index) {
                                        if (!visited[end]) {
                                            // 入队
                                            LinkListNode<Integer> childNode = new LinkListNode<>();
                                            childNode.setData(end);
                                            queue.insert(childNode);
                                            System.out.println("insert " + vertex[end]);
                                        }
                                    } else if (end == index) {
                                        if (!visited[begin]) {
                                            // 入队
                                            LinkListNode<Integer> childNode = new LinkListNode<>();
                                            childNode.setData(begin);
                                            queue.insert(childNode);
                                            System.out.println("insert " + vertex[begin]);
                                        }
                                    }

                                    if (visited[begin] && visited[end]) {
                                        visitedArc[j] = true;
                                    }
                                }
                            }
                            break;
                        }
                        case DIRECTED:
                        case DIRECTED_NETWORK: {
                            for (int j = 0; j < edgeNum && vertexList.size() < vertexNum; j++) {
                                if (!visitedArc[j]) {

                                    System.out.println("iterate arc " + j);

                                    EdgeListEdgeNode<W> edge = arc[j];
                                    int begin = edge.getBegin();
                                    int end = edge.getEnd();

                                    if (begin == index && !visited[end]) {
                                        // 入队
                                        LinkListNode<Integer> childNode = new LinkListNode<>();
                                        childNode.setData(end);
                                        queue.insert(childNode);
                                        System.out.println("insert " + vertex[end]);
                                    }

                                    if (visited[begin] && visited[end]) {
                                        visitedArc[j] = true;
                                    }
                                }
                            }
                            break;
                        }
                    }

                }

            }

        }

    }

    return vertexList;
}

  注意，边集数组若不进行特殊处理的话，每一层的顶点顺序取决于边集数组中结点顺序的定义。，如下有向网：

  若定义为如下边集数组时：

  广度优先遍历过程为：

  广度优先遍历结果为EADBFC。

  但如果把边集数组的定义做一些调整：

  广度优先遍历过程为：

  遍历结果为EADCBF，与之前的遍历结果并不相同。

  当然，你也可以选择在取出所有相关的顶点后，对这些顶点按下标排序，那么广度优先遍历的结果就是固定的了，与边集数组中结点的顺序无关。

  注：本文为程 杰老师《大话数据结构》的读书笔记，其中一些示例和代码是笔者阅读后自行编制的。