数据结构与算法(27):图的基本介绍(图的深度优先遍历,图的广度优先遍历)以及相关的案例代码

最新推荐文章于 2023-10-09 13:42:51 发布
最新推荐文章于 2023-10-09 13:42:51 发布
阅读量492 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 图的基本数据数据结构 图的深度遍历 数据结构 算法 图的广度优先遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42400763/article/details/109099787
版权

一. 图的基本介绍

为什么要有图?

回顾一下线性表和树

  1. 线性表局限于一个直接前驱和一个直接后继的关系
  2. 树也只能有一个直接前驱也就是父节点
  3. 当我们需要表示多对多的关系时， 这里我们就用到了图

图的举例说明

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

  1. 无向图

在这里插入图片描述
2. 有向图

在这里插入图片描述3. 带权图

在这里插入图片描述

图的表示方式

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

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

在这里插入图片描述上述说明:0和0之间为0就是说没有直接连通的关系.1和0之间为1就是说1和0是有直接连接的关系

  1. 邻接表
  • 邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在,会造成空间的一定损失.
  • 邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表组成

在这里插入图片描述说明:

  1. 标号为0的结点的相关联的结点为 1 2 3 4
  2. 标号为1的结点的相关联结点为0 4，
  3. 标号为2的结点相关联的结点为 0 4 5
  4. …

图的快速入门案例

我们先看一个图:

在这里插入图片描述再用邻接矩阵来表示:

在这里插入图片描述
说明:

  1. 1 表示能够直接连接
  2. 0 表示不能直接连接

思路分析
(1) 存储顶点String 使用 ArrayList
(2) 保存矩阵 int[][] edges

代码实现部分:

package com.qiu.graph;

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

public class Graph {
    //存储顶点集合
    private ArrayList<String> vertexList;
    //存储图对应的邻接矩阵
    private int[][] edges;
    //表示边的数目
    private int numOfEdges;

    public static void main(String[] args) {
        //测试图是否创建成功
        int n = 5;
        String[] vertexs = {"A","B","C","D","E"};
        //创建一个图的对象
        Graph graph = new Graph(n);
        //循环的添加顶点
        for (String value : vertexs){
            graph.insertVertex(value);
        }
        //添加边 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.showGragh();
    }

    //构造器
    public Graph(int n){
        //初始化邻接矩阵和vertexList
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
    }
    //常用的方法:图中的方法

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

    //得到边的数目
    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 showGragh(){
        for (int[] link : edges){
            System.out.println(Arrays.toString(link));
        }
    }
    //插入顶点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }


    /**
     *  //添加边
     * @param v1 表示点的下标,是第几个顶点
     * @param v2 表示第二个顶点对应的下标
     * @param weight 表示0或者1
     */
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }
}

代码结果:

在这里插入图片描述

图的遍历

所谓图的遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种访问策略:
(1)深度优先遍历
(2)广度优先遍历

深度优先遍历基本思想

(1) 图的深度优先搜索(Depth First Search) 。

  1. 深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。(一条线往下走)
  2. 我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。
  3. 深度优先搜索是一个递归的过程

深度优先遍历算法步骤

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

在这里插入图片描述从A开始走.下一个邻接点B ,B存在,继续访问C.然后以C为出发点访问,本来要访问D的,但是没有找到D.因为不邻接.所以回到上一个节点B,然后B和D是关联的,所以访问到了D,但是D和E并没有关联到,所以回到B,再来访问E.最后结束循环.

代码实现:

package com.qiu.graph;

import org.omg.CORBA.PUBLIC_MEMBER;

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

public class Graph {
    //存储顶点集合
    private ArrayList<String> vertexList;
    //存储图对应的邻接矩阵
    private int[][] edges;
    //表示边的数目
    private int numOfEdges;
    //定义给数组boolean[],记录结点是否被访问
    private boolean[] isVisited;

    public static void main(String[] args) {
        //测试图是否创建成功
        int n = 5;
        String[] vertexs = {"A","B","C","D","E"};
        //创建一个图的对象
        Graph graph = new Graph(n);
        //循环的添加顶点
        for (String value : vertexs){
            graph.insertVertex(value);
        }
        //添加边 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.showGragh();
        //测试一把我们的dfs遍历是否ok
        System.out.println("深度遍历ok");
        graph.dfs();
    }

    //构造器
    public Graph(int n){
        //初始化邻接矩阵和vertexList
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
        isVisited = new boolean[5];
    }



    /**
     * //得到第一个邻接结点的下标W
     * @param index
     * @return 如果存放就返回对应的下标,否则就返回-1
     */
    public int getFirstNeighbor(int index){
        for (int j = 0; j < vertexList.size(); j++) {
            if (edges[index][j] > 0){
                return j;
            }
        }
        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;
    }

    //深度优先遍历算法
    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节点已经被访问过我们应该查找下一个节点
            w = getNextNeighbor(i,w);
        }
    }

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

    //常用的方法:图中的方法

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

    //得到边的数目
    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 showGragh(){
        for (int[] link : edges){
            System.out.println(Arrays.toString(link));
        }
    }
    //插入顶点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }


    /**
     *  //添加边
     * @param v1 表示点的下标,是第几个顶点
     * @param v2 表示第二个顶点对应的下标
     * @param weight 表示0或者1
     */
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }
}

代码结果:

在这里插入图片描述
(2) 图的广度优先遍历

广度优先遍历基本思想

  图的广度优先搜索(Broad First Search) 。
类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点

广度优先遍历算法步骤

  1. 访问初始结点v并标记结点v为已访问。
  2. 结点v入队列
  3. 当队列非空时，继续执行，否则算法结束。
  4. 出队列，取得队头结点u。
  5. 查找结点u的第一个邻接结点w。
  6. 若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：
    6.1 若结点w尚未被访问，则访问结点w并标记为已访问。
    6.2 结点w入队列
    6.3 查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。

在这里插入图片描述

看图: 首先访问到的是A,然后看B是否能访问,就输出B,再以A为基础上去访问C,同样的以A的节点访问D,发现找不到了,我们就从队列中取出B,以B为基础,来访问,然后A,C访问过了,然后D能被访问到,就输出了D,同样再以B为中心去找到E,也能找到.再输出E.整个节点遍历结束后,发现都访问过了就退出了

//对一个节点进行广度优先遍历的方法
    private void bfs(boolean[] isVisited,int i){
        //根据设计,表示队列的头结点对应的下标
        int u;
        //整个过程中,邻接节点的下标
        int w;
        //因为整个过程中,需要一个队列,节点访问顺序的记录
        LinkedList queue = new LinkedList();
        //访问节点,输出节点的信息
        System.out.print(getValueByIndex(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.print(getValueByIndex(w)+"->");
                     //标记已经访问
                     isVisited[w] = true;
                     //入队
                     queue.addLast(w);
                 }
                 //以u为前一个节点找w后面的下一个邻接点,找以u行的下一个w的节点
                 //体现出我们的一个广度优先的经典特性
                 w = getNextNeighbor(u,w);
             }
        }
    }

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

代码运行结果:

在这里插入图片描述

图的广度优先VS图的深度优先

在这里插入图片描述
然后我们用代码插入这九条边的关系.

 String[] vertexs = {"0","1","2","3","4","5","6","7","8"};

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

在这里插入图片描述在这里插入图片描述由于代码运行结果显示,深度优先和广度优先结果还是有不一样的

风中有朵雨做的云yi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】图的深度遍历与广度遍历
流星雨的博客
03-23 6794
图是一种常见的数据格式，它的遍历主要分为两种： 深度优先遍历(DFS):类似于二叉树的前序前序遍历 广度优先遍历(BFS):类似于二叉树的层次遍历 一、出度与入度 在讲图的遍历之前，我们需要先了解图的数据结构。 对于图，我们一般定义横向是出度，纵向是入度。比如对于左图我们转成领接矩阵如右图 这里我们构建一个图的数据结构Graph，顺序遍历二维数组matrix的index[0]、index[1]、index[2]···获取出度。同理顺序遍历[0]index···获取入度。用java实现如下： p.
图的遍历——深度优先搜索（DFS）与广度优先搜索（BFS）（附带C语言源码）
weixin_73602725的博客
05-10 2983
在此之前我们学习过了图的一些基本概念，如同在二叉树中我们有前序遍历，中序遍历，后序遍历一般，在图中也有两种特殊的遍历方式——深度优先遍历与广度优先遍历。
数据结构学习笔记——图的遍历算法（深度优先搜索和广度优先搜索）
热门推荐
小宇y的博客
08-18 2万+
若通过邻接表表示图，则每个顶点都入队一次，即所需时间为O(|V|)，搜索顶点的邻接顶点所需时间为O(|E|)，其时间复杂度为O(|V|+|E|)。若通过邻接表表示图，则查找所有顶点的邻接顶点所需时间为O(|E|)，访问顶点所需时间为O(|V|)，即总时间复杂度为O(|V|+|E|)。4、查看V7单链表，其邻接顶点为2，即V3，它已经被访问过，于是回到V3单链表，搜索下一个未被访问的邻接顶点；11、查看V8单链表，其邻接顶点为4，即V5，已经被访问过，于是回到V5单链表，搜索下一个未被访问的邻接顶点；....
【数据结构】图以及图的遍历（深度遍历和广度遍历）
qq_25218219的博客
11-12 4368
图 在数学中，图是描述于一组对象的结构，其中某些对象对在某种意义上是“相关的”。这些对象对应于称为顶点的数学抽象（也称为节点或点），并且每个相关的顶点对都称为边（也称为链接或线）。通常，图形以图解形式描绘为顶点的一组点或环，并通过边的线或曲线连接。 图形是离散数学的研究对象之一。 ------百度百科 6.1 基本术语 图：记为 G＝( V, E ) 其中：V 是G
图详解第二篇：图的遍历（广度优先+深度优先）
m0_70980326的博客
10-09 3765
图的遍历详解：DFS+BFS
python基础编程：python实现树的深度优先遍历与广度优先遍历详解
01-20
本文实例讲述了python实现树的深度优先遍历与广度优先遍历。分享给大家供大家参考，具体如下： 广度优先(层次遍历) 从树的root开始，从上到下从左到右遍历整个树的节点 数和二叉树的区别就是，二叉树只有左右两个...
JavaScript树的深度优先遍历和广度优先遍历算法示例
10-18
两种常见的遍历方法是深度优先遍历（Depth-First Search, DFS）和广度优先遍历（Breadth-First Search, BFS）。在JavaScript中，我们可以使用递归或非递归的方法来实现这两种遍历。 1. **深度优先遍历**： 深度...
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
使用邻接表表示法创建无向图，然后使用非递归算法进行深度优先遍历和广度优先遍历
无向图建立、深度优先遍历和广度优先遍历实现算法[借鉴].pdf
10-14
无向图建立、深度优先遍历和广度优先遍历实现算法 本文将详细介绍无向图的建立、深度优先遍历和广度优先遍历的实现算法。这些算法是数据结构中非常重要的内容，掌握它们对后续学习和应用非常重要。 一、无向图的...
Java实现二叉树的深度优先遍历和广度优先遍历算法示例
08-27
本文详细介绍了Java实现二叉树的深度优先遍历和广度优先遍历算法，通过实例代码展示了深度优先遍历和广度优先遍历的实现过程，并对二叉树的定义、深度优先遍历与广度优先遍历算法原理与相关操作实现技巧进行了详细...
图的广度优先遍历
实践求真知
06-25 8020
广度优先遍历又称为宽度优先搜索，是最常见的图的搜索方法之一。广度优先搜索指从某一点出发，一次性访问所有未被访问的邻节点，再依次从这些已访问过的邻接点出发，一层一层地访问。广度优先遍历是按照广度优先搜索的方式对图进行遍历的。按照广度优先搜索的顺序，上图的访问顺序是：1 2 3 4 5 6广度优先遍历的秘籍：先被访问的节点，其邻节点先被访问。根据广度优先遍历的秘籍，先来先服务，可以借助队列实现。因为对每个节点只访问一次，所以可以设置一个辅助数组 visited[i] = false，表示第 i 个节点未被访问；
【数据结构】图的遍历：广度优先（BFS），深度优先（DFS）
小人物，大梦想！
09-21 4308
算法思想，广度优先生成树，深度优先生成树，算法实现
大话数据结构---（六）图的深度优先遍历和广度优先遍历
松落
03-30 1万+
我们已经掌握了如何存储图中的信息，即邻接矩阵，邻接表，十字链表等。那么我们该如何利用这些存储结构中的数据呢，或者说我该如何找到我想要的数据呢，这里我们就得学会如何遍历图结构，而接下来会和大家介绍两种常用的遍历方法，深度优先遍历和广度优先遍历。
图的遍历-深度优先遍历与广度优先遍历（C语言）
偶然路过的帅小伙z的博客
04-02 5181
目录 邻接矩阵及邻接表的创建 深度优先遍历（DFS） 邻接矩阵的深度优先遍历 结构定义 邻接矩阵的深度优先遍历操作 邻接矩阵的深度优先递归算法 邻接表的深度优先遍历 结构定义 邻接表的深度优先遍历操作 邻接表的深度优先递归算法 广度优先遍历（BFS） 邻接矩阵的广度遍历 结构定义 邻接矩阵的广度遍历算法 邻接表的广度优先遍历 结构定义 邻接表的遍历算法 广度优先遍历所需队列代码
图的遍历
在黑夜中前行
12-01 863
基本概念从给定图中任意指定的顶点（称为初始点）出发，按照某种搜索方法沿着图的边访问图中的所有顶点，使每个顶点仅被访问一次，这个过程称为图的遍历。如果给定图是连通的无向图或者是强连通的有向图，则遍历过程一次就能完成，并可按访问的先后顺序得到由该图所有顶点组成的一个序列。根据搜索方法的不同，图的遍历方法有两种：一种叫做深度优先搜索法（DFS）；另一种叫做广度优先搜索法（BFS）。 深度优先搜索深度优先搜
数据结构图及其遍历（邻接表存储方式的深度遍历和广度遍历）
m0_52910424的博客
11-26 1971
建立无向图G的邻接表存储结构，求其从任意顶点出发的广度优先搜索序列与深度优先搜索序列。（每个点优先去往周围未到达的点中编号最小的点）输入格式：第一行两个正整数n, m表示G中顶点数与边数接下来m行每行两个正整数u，v表示u点与v点之间有一条无向边若同一条边被输入两次，则自动增加一行输入 (1 <= u, v, w <= n) (1 <= n <= 500, 1 <= m <= 2000) 最后一行一个正整数w表示遍历的起始顶点 输出格式 第一行n个正整数表示广度优先搜索序列 第二行n个正整数表
【图论】图的深度优先遍历与广度优先遍历（图文讲解）
qq_49688477的博客
07-24 1万+
一、前言 看懂这篇博客你需要提前知道这些知识点 1.C++链式前向星存图； 2.dfs和bfs是什么以及基本概念； 3.C++STL中的queue，队列数据结构的简单知识点； 4.有关图的一些简单的概念； 图论是一个很重要的知识块，在学习如何遍历图之前，我们首先当然得知道要怎样去建图。在下面的内容里，我们将使用链式前向星来建图，如果对建图有什么问题的话可以移步这篇博客来学习。 链式前向星 在了解建图的方法后，我们当然要开始考虑如何遍历图中的每一个点，在这里，我们将使用两种最基础的遍历方式-----深度优先搜
数据结构——图的两种遍历【深度优先遍历-广度优先遍历】的区别用法
gqg_guan的博客
11-01 1万+
深度优先遍历-广度优先遍历
图的深度和广度遍历
m0_61641152的博客
06-01 2018
图是一种较为复杂的数据结构，它是一种非线性的数据结构，表示多对多的关系。树和线性表都是一种特殊的图。这里就简单的介绍图的深度和广度优先遍历。深度优先遍历即从一个节点找到和它相连接的最小节点后，又继续找最小节点相连接的最小节点，代码中使用了递归，为了防止重复找到，还会采用另一个数组来记录各节点是否被访问过。原理图： 代码： 广度优先遍历：从一个结点找到和它连接的所有节点并保存，接着从和它相邻的节点中编号从小到大开始遍历。同样要借助数组标记是否被访问，重复访问则不在保存。这里要采用循环队列的帮助。为重复访问
图的深度优先遍历和图的广度优先遍历算法的时间复杂度
最新发布
12-09
图的深度优先遍历和广度优先遍历算法的时间复杂度分别为O(n+e)和O(n+e)，其中n为图中节点的个数，e为图中边的个数。深度优先遍历算法使用递归的方法，时间复杂度为O(n²)，而广度优先遍历算法使用标记数组的方法，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值