java实现图的深度遍历

步骤

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

图的实现代码

package Graph;

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


/*
 * 矩阵实现
 */

/*
 * 1、存储图中的顶点   用String ArrayList保存
 * 2、用int [][]edges 表示邻接矩阵
 */
public class GraphDemo1 {
    private ArrayList<String> vertexList; //存储顶点集合
    private int[][]edges; //存储图的对应的邻接矩阵
    private int numOfEdges; //表示边的数目
    private boolean[] isVisited; //定义已被遍历的结点，true表示已被遍历
    //含参构造,n个数据
    public GraphDemo1(int n){
        //初始化矩阵
        edges 	   = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0; //默认边为零
       isVisited = new boolean[n];
    }

    //插入结点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }

    //添加边
    /*
     * v1，v2表示点的下标，即第几个顶点
     * weight表示描述相应关系的权值
     */
    public void insertEdge(int v1, int v2,int weight){
        edges[v1][v2] = weight;
        //无向图，对应权值也设为weight
        edges[v2][v1] = weight;
        numOfEdges ++;   //边+1
    }

    //返回结点的个数
    public int getNumOfVertex(){
        return vertexList.size();
    }

    //返回边的个数
    public int getNumOfEdges(){
        return numOfEdges;
    }

    //返回下标为i的元素
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }

    //返回v1，v2的权值
    public int getWeight(int v1 , int v2){
        return edges[v1][v2];
    }

    //显示图对应的邻接矩阵
    public void showGraph(){
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

    

}

深度遍历算法代码

//得到第一个邻接结点的下标w，index为矩阵行数，i为矩阵列数
    public int getFirstNeighbor(int index){
        for (int i = 0; i < vertexList.size(); i++) {
            if (edges[index][i] > 0)
                //如果存在，返回下标
                return  i;
        }
                //不存在，返回-1；
        return  -1;
    }

        //根据前一个邻接结点的下标来获取下一个邻接结点
    public int getNextNeighbor(int v1 , int v2){
        //v2为前一个邻接结点，前边都已经遍历过，直接跳过
        for (int i = v2+1; i < vertexList.size(); i++) {
            if(edges[v1][i] > 0)
                return  i;
        }
        return  -1;
    }

    //深度优先遍历算法

    //对dfs进行一个重载，实现对所有元素的遍历
    public void  dfs(){
        //遍历所有的结点，进行dfs
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i])
                dfs(isVisited,i);
        }
    }

    //带参实现
    private void dfs(boolean[] isVisited , int i){
        //首先访问该结点
        System.out.print(getValueByIndex(i) + "->");
        //将结点设置为已访问
        isVisited[i]  =  true;

        //获取邻接结点
        int w = getFirstNeighbor(i);
        //w ！= -1,表示没访问过
        while (w != -1){
            if  (!isVisited[w])   //如果没有被访问
                //递归
                dfs(isVisited,w);

            //如果w被访问过了
            w = getNextNeighbor(i,w);
        }
    }

测试类

package Graph;

public class MainClass {

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

        //创建图对象
        GraphDemo1 graph = new GraphDemo1(n);

        //添加顶点
        for(String vertex : VertexValue){

            graph.insertVertex(vertex);
        }

        //添加边
        //A-B  A-C   B-C   B-D   B-E
        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();

        //测试深度遍历算法
        System.out.println("");
        graph.dfs();
    }

}

输出