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

思路分析

package com.ran;


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

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();

        System.out.println("广度优先");
        hello.bfs();

    }

    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 i=0;i<dingdian.size();i++){
            if(juzhen[index][i]>0){
                return i;
            }
        }
        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.println(shuju(i)+"->");
        isVisited[i]=true;
        int w=getFirstNeighbor(i);

        while (w!=-1){
            if(!isVisited[w]){
                dfs(isVisited,w);
            }else {
                w=getNextNeighbor(i,w);
            }
        }


    }

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

    //对一个节点进行广度优先遍历的方法
    public void bfs(boolean[] isVisited,int i){
        int u;  //u表示队列头节点对应下标
        int w;  //邻接节点w
        //队列，记录节点访问的顺序
        LinkedList queue = new LinkedList<>();
        //访问节点，输出节点信息
        System.out.println(shuju(i)+"=>");
        //已访问
        isVisited[i]=true;
        //将节点加入队列
        queue.addLast(i);
        while (!queue.isEmpty()){
            //取出队列的头节点下标
            u=(Integer)queue.removeFirst();
            //得到第一个邻接点的下标w
            w=getFirstNeighbor(u);
            while (w!=-1){
                //是否访问过
                if(!isVisited[w]){
                    System.out.println(shuju(w)+"=>");
                    //标记已被访问
                    isVisited[w]=true;
                    //入队
                    queue.addLast(w);
                }
                //以u为前驱点，找w后面的下一个邻接点
                w=getNextNeighbor(u,w); //体现出广度优先
            }
        }
    }

    //遍历所有的节点，都进行广度优先搜索
    public void bfs(){
        for(int i=0;i<jiediangeshu();i++){
            if(!isVisited[i]){
                bfs(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++;
    }




}

代码运行效果如下：