图的深度优先算法分析及实现

思路分析

package com.shujujiegou;


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

public class Hello {
    private ArrayList<String> dingdian; //存储顶点集合
    private int[][] juzhen; //存储邻接矩阵
    private int bianshu; // 表示边的数目

    //定义给数组boolean【】 记录某个节点是否呗访问过
    private boolean[] isVisited;

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

        //创建图对象
        Hello hello = new Hello(n);

        //循环添加顶点
        for (String s : Vertexs) {
            hello.charudian(s);
        }

        //添加边 A-B A-C B-C B-D B-E
        hello.charubian(0,1,1);
        hello.charubian(0,2,1);
        hello.charubian(1,2,1);
        hello.charubian(1,3,1);
        hello.charubian(1,4,1);

        //显示邻接矩阵
        hello.xianshijuzhen();

        //深度遍历测试
        System.out.println("深度遍历");
        hello.dfs();

    }

    public Hello(int n){
        //初始化矩阵和arraylist
        juzhen=new int[n][n];
        dingdian=new ArrayList<String>(n);
        bianshu=0;
        isVisited=new boolean[5];
    }

    //得到第一个临接节点的下标 如果存在就返回对应的下标 否则就返回-1
    public int getFirstNeighbor(int index){
        for(int j=0;j<dingdian.size();j++){
            if(juzhen[index][j]>0){
                return j;
            }
        }
        return -1;
    }


    //根据前一个邻接节点的下标来获取下一个邻接节点
    public int getNextNeighbor(int v1,int v2){
        for(int j=v2+1;j<dingdian.size();j++){
            if(juzhen[v1][j]>0){
                return j;
            }
        }
        return -1;
    }



    //深度优先算法
    private void dfs(boolean[] isVisited,int i){
        //首先我们访问该节点，输出
        System.out.print(shuju(i)+"->");
        //将这个节点设置为已经访问过
        isVisited[i]=true;
        //查找节点i的第一个邻接节点w
        int w=getFirstNeighbor(i);
        while (w!=-1){
            //说明有邻接节点
            if(!isVisited[w]){
                dfs(isVisited,w);
            }
            //如果w这个节点已经被访问过
            w=getNextNeighbor(i,w);
        }
    }

    //对dfs进行重载，遍历我们所有的节点并进行dfs
    public void dfs(){
        //遍历所有的节点进行dfs
        for (int i=0;i<jiediangeshu();i++){
            if(!isVisited[i]){
                dfs(isVisited,i);
            }
        }
    }





    //显示图对应的矩阵
    public void xianshijuzhen(){
        for(int []a:juzhen){
            System.out.println(Arrays.toString(a));
        }
    }

    //返回节点的个数
    public int jiediangeshu(){
        return dingdian.size();
    }

    public int bianshumu(){
        return bianshu;
    }

    //返回节点i（下标）对应的数据
    public String shuju(int i){
        return dingdian.get(i);
    }

    //插入节点
    public void charudian(String dian){
        dingdian.add(dian);
    }

    //返回v1和v2的权值
    public int quanzhi(int v1,int v2){
        return juzhen[v1][v2];
    }

    //添加边  v1表示顶点下标即第几个顶点 v2表示第二个顶点对应的下标 weight表示他们值
    public void charubian(int v1,int v2,int weight){
        juzhen[v1][v2]=weight;
        juzhen[v2][v1]=weight;
        bianshu++;
    }




}

代码运行效果如下：