图（深度优先和广度优先遍历）

最新推荐文章于 2024-05-18 23:15:22 发布

TDdate

最新推荐文章于 2024-05-18 23:15:22 发布

阅读量239

点赞数

分类专栏：算法与数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/tong_yerui/article/details/119873215

版权

算法与数据结构专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.基本介绍

图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。结点可以称之为顶点。如图：

图可以分为有向图、无向图、带权图。

图的表示方式有两种：二维数组表示（邻接矩阵），链表表示（邻接表）。

邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点而言，矩阵是的row和col表示的是1....n个点.如图所示:

邻接表

①邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在，会造成空间的一定损失。

②邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间兰妃，邻接表由数组+链表组成。如图所示：

2.深度优先遍历

基本思想：

①深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点，可以这样理解：每次都在访问完当前结点后先访问当前结点的第一个邻接结点。

②我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。

③显然，深度优先搜索是一个递归的过程。

算法步骤：

1）访问初始结点v，并标记结点v为已访问。

2）查找结点v的第一个邻接结点w。

3）若w存在，则继续执行4，如果w不存在，则回到第一步，将从v的下一个结点继续。

4）若w未被访问，对w进行深度优先遍历递归（即把w当作另一个v，然后进行步骤123）。

5）查找结点v的w邻接结点的下一个邻接结点，转到步骤3.

代码实现：

 public void dfs(boolean []isVisited,int i){
        //首先我们访问该结点,输出
        System.out.print(getValueByIndex(i)+"-->");
        //将结点设置为已经访问
        isVisited[i]=true;
        //查找结点i的第一个邻接结点w
        int w = getFirstNeighbor(i);
        while (w!=-1){// 说明有
            if(!isVisited[w]){
                dfs(isVisited,w);
            }
            w=getNextNeighbor(i,w);
        }
    }
    //对dfs 进行一个重载, 遍历我们所有的结点，并进行 dfs
    public void dfs(){
        isVisited=new boolean[vertexList.size()];
        for(int i=0;i<vertexList.size();i++){
            if(!isVisited[i]){
                dfs(isVisited,i);
            }

        }
    }

3.广度优先遍历

基本思想：图的广度优先搜索，类似于一个分层搜索的过程，广度优先遍历使用一个队列以保持访问过的结点的顺序，以便按这个顺序访问这些结点的邻接结点。

算法步骤：

①访问初始结点v并标记结点v为已访问。

②结点v入队列。

③当队列非空时，继续执行，否则算法结束。

④出队列，取得队头结点u。

⑤查找结点u的第一个邻接结点。

⑥若结点的邻接结点w不存在，则转到步骤3，否则循环执行以下步骤：

1.若结点w尚未被访问，，则访问结点w并标记为已访问。

2.结点w队列。

3.查找结点u的继w邻接结点后一个邻接结点w，转到步骤6.

代码实现：

  public void bfs(boolean []isVisited,int i){
        int u;// 表示队列的头结点对应下标
        int w;// 邻接结点w
        // 队列，记录结点访问的顺序
        LinkedList queue  = new LinkedList();
        // 访问结点，输出结点信息
        System.out.print(getValueByIndex(i) + "=>");
        // 标记为已访问
        isVisited[i]=true;
        //将结点加入队列
        queue.addLast(i);
        while (!queue.isEmpty()){
            //取出队列的头结点下标
            u= (int) queue.removeFirst();
            //得到第一个邻接结点的下标 w
            w=getFirstNeighbor(i);
            while (w!=-1){
                //是否访问过
                if(!isVisited[w]){
                    System.out.print(getValueByIndex(w) + "=>");
                    //标记已经访问
                    isVisited[w]=true;
                    //入队
                    queue.addLast(w);
                }
                //以u为前驱点，找w后面的下一个邻结点
                w=getNextNeighbor(u,w);
            }


        }
    }
    //遍历所有的结点，都进行广度优先搜索
    public void bfs(){
        isVisited=new boolean[vertexList.size()];
        for (int i=0;i<vertexList.size();i++){
            if(!isVisited[i]){
                bfs(isVisited,i);
            }

        }
    }

结合上述的两种遍历方式，下面是它们的测试的代码全部：


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

public class Graph {
    public static void main(String[] args) {
//        String Vertexs[] = {"A", "B", "C", "D", "E"};
        String Vertexs[] = {"1", "2", "3", "4", "5", "6", "7", "8"};

        //创建图对象
        Graph graph = new Graph(Vertexs.length);
        //循环的添加顶点
        for(String vertex: Vertexs) {
            graph.insertVertex(vertex);
        }
        //添加边
        //A-B A-C B-C B-D B-E
//		graph.insertEdge(0, 1, 1); // A-B
//		graph.insertEdge(0, 2, 1); //
//		graph.insertEdge(1, 2, 1); //
//		graph.insertEdge(1, 3, 1); //
//		graph.insertEdge(1, 4, 1); //
        //更新边的关系
        graph.insertEdge(0, 1, 1);
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);
        graph.insertEdge(3, 7, 1);
        graph.insertEdge(4, 7, 1);
        graph.insertEdge(2, 5, 1);
        graph.insertEdge(2, 6, 1);
        graph.insertEdge(5, 6, 1);
        //显示一把邻结矩阵
        graph.showGraph();
        System.out.println("深度遍历");
        graph.dfs();
        System.out.println("广度优先!");
        graph.bfs();

    }
    private ArrayList<String> vertexList;// 存储顶点的集合
    private int[][] edges;// 存储图的邻接矩阵
    private int numOfEdges;// 表示边的数目
    //定义给数组boolean[], 记录某个结点是否被访问
    private boolean []isVisited;
   // 构造器
    public Graph(int n) {
        edges=new int[n][n];
        vertexList=new ArrayList<String>(n);
        numOfEdges=0;
    }

    //得到第一个邻接结点的下标 w

    /**
     *
     * @param index
     * @return 如果存在就返回对应的下标，否则返回-1
     */
    public int getFirstNeighbor(int index){
        for (int i=0;i<vertexList.size();i++){
            if(edges[index][i]>0){
               return i;
            }
        }
        return -1;

    }
    //根据前一个邻接结点的下标来获取下一个邻接结点
    public int getNextNeighbor(int v1,int v2){
        for(int j=v2+1;j<vertexList.size();j++){
            if(edges[v1][j]>0){
                return j;
            }
        }
        return -1;
    }
    //深度优先遍历算法
    //i 第一次就是 0
    public void dfs(boolean []isVisited,int i){
        //首先我们访问该结点,输出
        System.out.print(getValueByIndex(i)+"-->");
        //将结点设置为已经访问
        isVisited[i]=true;
        //查找结点i的第一个邻接结点w
        int w = getFirstNeighbor(i);
        while (w!=-1){// 说明有
            if(!isVisited[w]){
                dfs(isVisited,w);
            }
            w=getNextNeighbor(i,w);
        }
    }
    //对dfs 进行一个重载, 遍历我们所有的结点，并进行 dfs
    public void dfs(){
        isVisited=new boolean[vertexList.size()];
        for(int i=0;i<vertexList.size();i++){
            if(!isVisited[i]){
                dfs(isVisited,i);
            }

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


        }
    }
    //遍历所有的结点，都进行广度优先搜索
    public void bfs(){
        isVisited=new boolean[vertexList.size()];
        for (int i=0;i<vertexList.size();i++){
            if(!isVisited[i]){
                bfs(isVisited,i);
            }

        }
    }
    //图中常用的方法
    //返回结点的个数
    public int getNumOfVertex(){
        return vertexList.size();
    }
    //显示图对应的矩阵
    public void showGraph(){
        for(int[] ea:edges){
            System.out.println(Arrays.toString(ea));
        }

    }
    //得到边的数目
    public int getNumOfEdges(){
        return numOfEdges;
    }
    //返回结点i(下标)对应的数据 0->"A" 1->"B" 2->"C"
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }
    //返回v1和v2的权值
    public int getWeight(int v1,int v2){
        return edges[v1][v2];
    }
    //插入结点
    public void insertVertex(String insertValue){
        vertexList.add(insertValue);
    }
    //添加边
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2]=weight;
        numOfEdges++;
    }
}

TDdate

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
图（深度优先和广度优先遍历）

1.基本介绍图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。结点可以称之为顶点。如图：图可以分为有向图、无向图、带权图。图的表示方式有两种：二维数组表示（邻接矩阵），链表表示（邻接表）。邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点而言，矩阵是的row和col表示的是1....n个点.如图所示:邻接表①邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在，会造成空间的一定损失。②邻接表的实现只关心存在的边，不关心不存在的边..
复制链接

扫一扫

专栏目录