图的深度优先遍历JAVA代码实现及清晰思路注释

package day08;

//深度优先遍历-->解决迷宫问题
//思路，访问当前顶点，接着访问当前顶点的下一个结点，然后当前顶点的下一个结点作为当前结点，重复直到访问完所有元素
public class DFS {
    public static void main(String[] args) {

        char[] vertx = new char[]{'A','B','C','D','E'};

        int[][] matrix = {
                //A  B  C  D  E
       /* A*/{ 0, 1, 0, 0, 1 },
       /* B*/{ 1, 0, 1, 1, 0 },
      /* C*/ { 0, 1, 0, 1, 0 },
     /* D*/  { 0, 1, 1, 0, 0 },
    /* E*/   { 1, 0, 0, 0, 0 }
        };

        Graph graph = new Graph(vertx.length, vertx, matrix);
        graph.DFS(1);//从A顶点开始深度优先，预期结果ABCDE

        //从B顶点开始深度优先，预期结果BAECD
    }

}
class Graph {
    int vertexNum;//结点的个数
    char [] vertex;//顶点数组
    int [][] matrix;//邻接矩阵
    int [] isVisited;
    //构造函数
    public Graph(int vertexNum, char[] vertex, int[][] matrix) {
        this.vertexNum = vertexNum;
        this.vertex = vertex;
        this.matrix = matrix;

        isVisited = new int[vertexNum];
    }

    //深度优先遍历

    /**
     *
     * @param v 当前顶点在邻接矩阵对应的下标
     * @return v 的下一个未访问顶点 w, 不存在返回-1
     */
    public int getFirstNeighbour(int v) {
        for(int w = 0; w < matrix.length; w ++) {
            if (matrix[v][w] != 0 && isVisited[w] != 1) {
                return w;
            }
        }
        return -1;
    }

    /** 功能：防止当前路径的深度遍历已经到头，需要开始另一条路径的深度遍历
     *
     * @param v 当前节点
     * @param w 当前节点的第一个邻接结点
     * @return  当前节点的第二个邻接节点, -1 表示没有
     */
    public int getNext(int v, int w) {
        for(int i = w + 1; i < vertexNum; i ++) {
            if (matrix[v][i] != 0 && isVisited[i] != 1) {
                return i;
            }
        }

        return -1;
    }

    public void DFS(int v) {
        System.out.println(vertex[v]);
        isVisited[v] = 1;
        int w = getFirstNeighbour(v);
        while (w != -1) {

            DFS(w);

            w = getNext(v,w);
        }
    }
    
    //防止有不连通的结点没有被遍历到
    public void DFSCheck() {
        for(int i = 0; i < vertexNum; i ++) {
            if (isVisited[i] != 1) {
                System.out.println(vertex[i]);
            }
        }
    }
}