【数据结构与算法】第十四章：图的概述、无向图（邻接矩阵、邻接表、深度/广度优先搜索、路径查找）

最新推荐文章于 2023-06-26 12:21:09 发布
最新推荐文章于 2023-06-26 12:21:09 发布
阅读量812 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tu_wer/article/details/120375227
版权

14.1、图的实际应用

在现实生活中，有许多应用场景会包含很多点以及点点之间的连接，而这些应用场景都可以用即将要学习的图
这种数据结构去解决。

  • 地图

    生活中经常使用的地图，基本上是由城市以及连接城市的道路组成，如果把城市看做是一个一个的点，把道路看做是一条一条的连接，那么地图就是将要学习的图这种数据结构

  • 电路图

    生活中经常见到的集成电路板，它其实就是由一个一个触点组成，并把触点与触点之间通过线进行连接，这也是即将要学习的图这种数据结构的应用场景

14.2、图的定义及分类

  • 定义

    图是由一组顶点和一组能够将两个顶点相连的边组成的

在这里插入图片描述

  • 特殊的图
    • 自环：即一条连接一个顶点和其自身的边
    • 平行边：连接同一对顶点的两条边

在这里插入图片描述

  • 图的分类

    按照连接两个顶点的边的不同，可以把图分为以下两种：

    • 无向图：边仅仅连接两个顶点，没有其他含义
    • 有向图：边不仅连接两个顶点，并且具有方向

14.3、无向图

1）图的相关术语

  • 相邻顶点

    当两个顶点通过一条边相连时，称这两个顶点是相邻的，并且称这条边依附于这两个顶点

  • 度

    某个顶点的度就是依附于该顶点的边的个数

  • 子图

    是一幅图的所有边的子集(包含这些边依附的顶点)组成的图

  • 路径

    是由边顺序连接的一系列的顶点组成

  • 环

    是一条至少含有一条边且终点和起点相同的路径

在这里插入图片描述

  • 连通图

    如果图中任意一个顶点都存在一条路径到达另外一个顶点，那么这幅图就称之为连通图

  • 连通子图

    一个非连通图由若干连通的部分组成，每一个连通的部分都可以称为该图的连通子图

在这里插入图片描述

2）图的存储结构

要表示一幅图，只需要表示清楚以下两部分内容即可：

  1. 图中所有的 顶点
  2. 所有连接顶点的 边

常见的图的存储结构有两种：邻接矩阵 和 邻接表

1、邻接矩阵
  1. 使用一个 V * V 的 二维数组 int [V] [V] adj，把索引的值看做是顶点
  2. 如果顶点 v 和顶点 w 相连，只需要将 adj [v] [w] 和adj [w] [v] 的 值设置为1，否则设置为0即可

在这里插入图片描述

很明显，邻接矩阵这种存储方式的 空间复杂度是 V^2 的，如果处理的问题规模比较大的话，内存空间极有可能不够用

2、邻接表

  1. 使用一个大小为V的数组 Queue[V] adj，把索引看做是顶点

  2. 每个索引处 adj[v] 存储了一个 队列，该队列中存储的是所有与该顶点相邻的其他顶点

在这里插入图片描述

很明显，邻接表的空间并不是是线性级别的，所以后面一直采用邻接表这种存储形式来表示图

3）图的实现

1、图的API设计

在这里插入图片描述

2、代码实现
package chapter14;

import chapter03.Queue;

/**
 * @author 土味儿
 * Date 2021/9/15
 * @version 1.0
 * 无向图
 */
public class Graph {
    /**
     * 顶点数量
     */
    private final int vNum;
    /**
     * 边数量
     */
    private int eNum;
    /**
     * 邻接表
     */
    private Queue<Integer>[] adj;

    /**
     * 构造器
     * @param vNum
     * @param eNum
     * @param adj
     */
    public Graph(int vNum, int eNum, Queue<Integer> adj) {
        // 初始化顶点数量
        this.vNum = vNum;
        // 初始化边数量
        this.eNum = 0;
        // 初始化邻接表
        this.adj = new Queue[vNum];
        // 初始化邻接表中的空队列
        for (int i = 0; i < vNum; i++) {
            this.adj[i] = new Queue<Integer>();
        }
    }

    /**
     * 得到顶点数量
     * @return
     */
    public int getVNum(){
        return vNum;
    }

    /**
     * 得到边数量
     * @return
     */
    public int geteNum(){
        return eNum;
    }

    /**
     * 添加一条边v-w
     * @param v
     * @param w
     */
    public void addEdge(int v,int w){
        // 因为是无向图，v、w分别加入到对方的链表中
        this.adj[v].enQueue(w);
        this.adj[w].enQueue(v);
        // 边数量加1
        eNum++;
    }

    /**
     * 获取顶点v的所有相邻顶点
     * @param v
     * @return
     */
    public Queue<Integer> adj(int v){
        return this.adj[v];
    }
}

4）图的搜索

在很多情况下，需要遍历图，得到图的一些性质，例如， 找出图中与指定的顶点相连的所有顶点，或者判定某个顶点与指定顶点是否相通，是非常常见的需求。 最经典的算法有 深度优先搜索 和 广度优先搜索

1、深度优先搜索

所谓的深度优先搜索，指的是在搜索时，如果遇到一个结点既有子结点，又有兄弟结点，那么 先找子结点，然后找 兄弟结点

在这里插入图片描述

由于边是没有方向的，所以，如果4和5顶点相连，那么4会出现在5的相邻链表中，5也会出现在4的相邻链表中，那么为了不对顶点进行重复搜索，应该要有相应的标记来表示当前顶点有没有搜索过，可以使用一个：

布尔类型的数组 boolean[V] marked，索引代表顶点，值代表当前顶点是否已经搜索

如果已经搜索，标记为true，如果没有搜索，标记为false

在这里插入图片描述

package chapter14;

/**
 * @author 土味儿
 * Date 2021/9/16
 * @version 1.0
 * 深度优先搜索
 */
public class DepthFirstSearch {
    /**
     * 记录某个顶点是否被搜索过
     * 索引表示顶点
     * 值true：搜索过
     * 值false：未搜索过
     */
    private boolean[] marked;
    /**
     * 记录有多少个顶点与s顶点相通
     */
    private int count;

    /**
     * 构造深度优先搜索对象
     * 找出g图中所有与s顶点相通的顶点
     * @param g
     * @param s
     * @return
     */
    public DepthFirstSearch(Graph g,int s) {
        // 初始化marked数组
        this.marked = new boolean[g.getVNum()];

        // 初始化与顶点s相通的顶点数量
        this.count = 0;

        // 从s开始遍历搜索
        dfs(g,s);
    }

    /**
     * 判断w与s是否相通
     * @param w
     * @return
     */
    public boolean marked(int w){
        return this.marked[w];
    }

    /**
     * 判断与s相通的顶点数量
     * @return
     */
    public int count(){
        return this.count;
    }

    /**
     * 使用深度优先算法找出g图中与v相通的所有顶点
     * @param g
     * @param v
     */
    private void dfs(Graph g,int v){
        // 开始搜索v，标识为已搜索
        this.marked[v] = true;

        // 遍历v顶点的相通顶点队列
        for (Integer w : g.adj(v)) {
            // 如果当前w顶点没有被搜索过，就递归搜索
            if(!marked[w]){
                dfs(g,w);
            }
        }

        // 相通的顶点数量+1
        count++;
    }
}

package chapter13;

import chapter14.DepthFirstSearch;
import chapter14.Graph;
import org.junit.Test;

/**
 * @author 土味儿
 * Date 2021/9/16
 * @version 1.0
 * 深度优先搜索测试
 */
public class DepthFirstSearchTest {
    @Test
    public void test() {
        // 准备图对象
        Graph g = new Graph(13);
        g.addEdge(0, 1);
        g.addEdge(0, 2);
        g.addEdge(0, 6);
        g.addEdge(0, 5);
        g.addEdge(5, 3);
        g.addEdge(5, 4);
        g.addEdge(4, 6);
        g.addEdge(3, 4);

        g.addEdge(7, 8);

        g.addEdge(9, 10);
        g.addEdge(9, 11);
        g.addEdge(9, 12);
        g.addEdge(11, 12);

        // 准备深度优先搜索对象
        DepthFirstSearch search = new DepthFirstSearch(g, 0);

        // 查询与某个顶点相通的顶点数量
        int count = search.count();
        System.out.println("与起点0相通的顶点数量：" + count);

        // 查询某个顶点与起点是否相通
        boolean marked1 = search.marked(5);
        System.out.println("顶点5与起点是否相通："+marked1);

        boolean marked2 = search.marked(7);
        System.out.println("顶点7与起点是否相通："+marked2);
    }
}

与起点0相通的顶点数量：7
顶点5与起点是否相通：true
顶点7与起点是否相通：false
2、广度优先搜索

所谓广度优先搜索，指的是在搜索时，如果遇到一个节点既有子节点，又有兄弟节点，那么 先找兄弟节点，然后 找子结点

在这里插入图片描述

在这里插入图片描述

package chapter14;

import chapter03.Queue;

/**
 * @author 土味儿
 * Date 2021/9/16
 * @version 1.0
 * 广度优先搜索
 */
public class BreadthFirstSearch {
    /**
     * 记录某个顶点是否被搜索过
     * 索引表示顶点
     * 值true：搜索过
     * 值false：未搜索过
     */
    private boolean[] marked;
    /**
     * 记录有多少个顶点与s顶点相通
     */
    private int count;
    /**
     * 存储待搜索邻接表中的顶点
     */
    private Queue<Integer> waitSearch;

    /**
     * 构造广度优先搜索对象
     * 找出g图中所有与s顶点相通的顶点
     * @param g
     * @param s
     * @return
     */
    public BreadthFirstSearch(Graph g, int s) {
        // 初始化marked数组
        this.marked = new boolean[g.getVNum()];

        // 初始化与顶点s相通的顶点数量
        this.count = 0;

        // 初始化辅助队列
        waitSearch = new Queue<>();

        // 从s开始遍历搜索
        bfs(g,s);
    }

    /**
     * 判断w与s是否相通
     * @param w
     * @return
     */
    public boolean marked(int w){
        return this.marked[w];
    }

    /**
     * 判断与s相通的顶点数量
     * @return
     */
    public int count(){
        return this.count;
    }

    /**
     * 使用广度优先算法找出g图中与v相通的所有顶点
     * 递归方式
     * @param g
     * @param v
     */
    private void bfs(Graph g,int v){
        // 开始搜索v，标识为已搜索
        this.marked[v] = true;

        // 让顶点v进入队列
        waitSearch.enQueue(v);

        while(!waitSearch.isEmpty()){
            // 弹出一个待搜索的顶点
            Integer wait = waitSearch.deQueue();

            // 遍历v顶点的相通顶点队列
            for (Integer w : g.adj(v)) {
                // 如果当前w顶点没有被搜索过，就递归搜索
                if(!marked[w]){
                    bfs(g,w);
                }
            }

        }

        // 相通的顶点数量+1
        count++;
    }

    /**
     * 使用广度优先算法找出g图中与v相通的所有顶点
     * 非递归方式
     * 需要有node节点类支撑
     *
     * @param g
     * @param v
     */
    private void bfs1(Graph g,int v){
        // 开始搜索v，标识为已搜索
        this.marked[v] = true;

        // 让顶点v进入队列
        waitSearch.enQueue(v);

        while(!waitSearch.isEmpty()){
            // 弹出一个待搜索的顶点
            Integer wait = waitSearch.deQueue();

            // 弹出的顶点是有左子节点，把左子结点存入队列

            // 弹出的顶点是有右子节点，把右子结点存入队列

            // 相通的顶点数量+1
            count++;
        }
    }
}

5）案例-畅通工程续1

某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。目前的道路状况，9号城市和10号城市是否相通？9号城市和8号城市是否相通？

在测试数据文件夹中有一个trffic_project.txt文件，它就是道路统计表，下面是对数据的解释：

在这里插入图片描述

总共有20个城市，目前已经修改好了7条道路，问9号城市和10号城市是否相通？9号城市和8号城市是否相通？

  • 解题思路：
    1. 创建一个图Graph对象，表示城市
    2. 分别调用addEdge(0,1)，addEdge(6,9)，addEdge(3,8)，addEdge(5,11)，addEdge(2,12)，addEdge(6,10)，addEdge(4,8)，表示已经修建好的道路把对应的城市连接起来
    3. 通过Graph对象和顶点9，构建 DepthFirstSearch 对象或 BreadthFirstSearch 对象
    4. 调用搜索对象的 marked(10) 方法和 marked(8) 方法，即可得到9号城市与10号城市以及9号城市与8号城市是否相通
package chapter14;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author 土味儿
 * Date 2021/9/15
 * @version 1.0
 * 案例：畅通工程
 */
public class TrafficProject {
    public static void main(String[] args) throws IOException {
        // 创建缓冲输入流读取BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(TrafficProject.class.getClassLoader().getResourceAsStream("trffic_project.txt")));

        // 读取第一行数据：城市数量
        int totalNum = Integer.parseInt(br.readLine());

        // 构建一个图对象
        Graph g = new Graph(totalNum);

        // 读取第二行数据：已修好的道路数量
        int roadNum = Integer.parseInt(br.readLine());

        // 循环读取已经修建好的道路，并调用addEdge方法
        for (int i = 1;i<=roadNum;i++){
            String line = br.readLine();
            String[] str = line.split(" ");
            int p = Integer.parseInt(str[0]);
            int q = Integer.parseInt(str[1]);

            g.addEdge(p,q);
        }

        // 根据图g和顶点9构建图的搜索对象
        //DepthFirstSearch search = new DepthFirstSearch(g, 9);
        BreadthFirstSearch search = new BreadthFirstSearch(g, 9);

        //调用搜索对象的marked(10)方法和marked(8)方法
        boolean marked1 = search.marked(10);
        boolean marked2 = search.marked(8);

        System.out.println("9号城市与10号城市是否连通："+marked1);
        System.out.println("9号城市与8号城市是否连通："+marked2);
    }
}

9号城市与10号城市是否连通：true
9号城市与8号城市是否连通：false

6）路径查找

在实际生活中，地图是经常使用的一种工具，通常会用它进行导航，输入一个出发城市，输入一个目的地城市，就可以把路线规划好，而在规划好的这个路线上，会路过很多中间的城市。

这类问题翻译成专业问题就是： 从s顶点到v顶点是否存在一条路径？如果存在，请找出这条路径。

在这里插入图片描述

例如在上图上查找顶点0到顶点4的路径用红色标识出来，那么可以把该路径表示为 0-2-3-4

1、路径查找API设计

在这里插入图片描述

2、路径查找实现

实现路径查找，最基本的操作还是得遍历并搜索图，所以， 实现暂且基于深度优先搜索来完成。其搜索的过程是比较简单的。添加了edgeTo[]整型数组，这个整型数组会记录从每个顶点回到起点s的路径。 如果把顶点设定为0，那么它的搜索可以表示为下图：

在这里插入图片描述

在这里插入图片描述

根据最终edgeTo的结果，很容易能够找到从起点0到任意顶点的路径

package chapter14;

import chapter03.Stack;

/**
 * @author 土味儿
 * Date 2021/9/16
 * @version 1.0
 * 深度优先路径
 */
public class DepthFirstPaths {
    /**
     * 记录某个顶点是否被搜索过
     * 索引表示顶点
     * 值true：搜索过
     * 值false：未搜索过
     */
    private boolean[] marked;
    /**
     * 起点
     */
    private int s;
    /**
     * 索引代表顶点
     * 值代表从起点s到当前顶点路径上的最后一个顶点
     */
    private int[] edgeTo;

    /**
     * 构造深度优先搜索对象，使用深度优先搜索找出g图中，起点为s的所有路径
     *
     * @param g
     * @param s
     */
    public DepthFirstPaths(Graph g, int s) {
        // 初始化marked
        this.marked = new boolean[g.getVNum()];

        // 初始化起点
        this.s = s;

        // 初始化edgeTo数组
        this.edgeTo = new int[g.getVNum()];

        // 从起点s开始搜索
        dfs(g, s);
    }

    /**
     * 使用深度优先搜索找出g图中v顶点的所有相邻顶点
     *
     * @param g
     * @param v
     */
    private void dfs(Graph g, int v) {
        // 开始搜索v，标识为已搜索
        this.marked[v] = true;

        // 遍历v顶点的相通顶点
        for (Integer w : g.adj(v)) {
            if (!this.marked[w]) {
                // w的前一个顶点为v
                edgeTo[w] = v;
                dfs(g, w);
            }
        }
    }

    /**
     * 判断v顶点到s起点是否有路径
     *
     * @param v
     * @return
     */
    public boolean hasPathTo(int v) {
        return this.marked[v];
    }

    /**
     * 找出从起点s到顶点v的路径（经过的顶点；可能不唯一）
     *
     * @param v
     * @return
     */
    public Stack<Integer> pathTo(int v) {
        // 顶点v到起点没有路径，返回null
        if (!hasPathTo(v)) {
            return null;
        }

        // 创建栈对象，存储路径中顶点
        Stack<Integer> path = new Stack<>();

        // 从顶点v向前循环查找，到起点s为止
        for (int x = v; x != s; x = edgeTo[x]) {
            // 把查到的每个点放入栈中
            path.push(x);
        }

        // 把起点放入栈中
        path.push(s);

        // 返回栈
        return path;
    }
}

package chapter14;

import chapter03.Stack;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author 土味儿
 * Date 2021/9/16
 * @version 1.0
 */
public class DepthFirstPathsTest {
    public static void main(String[] args) throws IOException {
        // 创建缓冲输入流读取BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(DepthFirstPathsTest.class.getClassLoader().getResourceAsStream("road_find.txt")));

        // 读取第一行数据：城市数量
        int totalNum = Integer.parseInt(br.readLine());

        // 构建一个图对象
        Graph g = new Graph(totalNum);

        // 读取第二行数据：已修好的道路数量
        int roadNum = Integer.parseInt(br.readLine());

        // 循环读取已经修建好的道路，并调用addEdge方法
        for (int i = 0; i < roadNum; i++) {
            String line = br.readLine();
            int p = Integer.parseInt(line.split(" ")[0]);
            int q = Integer.parseInt(line.split(" ")[1]);

            g.addEdge(p, q);
        }

        // 根据图g和顶点0构建图的搜索对象
        DepthFirstPaths paths = new DepthFirstPaths(g, 0);

        // 调用搜索对象的pathTo(4)方法得到路径
        Stack<Integer> path = paths.pathTo(4);

        //遍历打印
        for (Integer v : path) {
            System.out.print(v + " ");
        }
    }
}
  • road_find.txt
6
8
0 2
0 1
2 1
2 3
2 4
3 5
3 4
0 5

// 运行结果
0 2 3 4
土味儿~
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
邻接矩阵与深度优先搜索算法
LHFX0707的博客
05-04 338
它采用递归的方式进行，从某个起始节点开始，尽可能深地搜索树的分支。当节点v的所在边都被探寻过后，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。邻接矩阵是一种常用的数据结构，用于存储有向图或无向图中各顶点之间的连接关系。在邻接矩阵中，矩阵的行和列都表示图中的顶点，矩阵的元素值表示对应顶点对之间是否存在边。对于有向图而言，若顶点i到顶点j存在一条有向边，则邻接矩阵中第i行第j列的元素值为1，否则为0。邻接矩阵A的对角线上的值均为0，因为节点无自环。
邻接矩阵—图的存储结构
wmy0217_的博客
02-15 1万+
文章目录邻接矩阵1、邻接矩阵表示法2、无向图的邻接矩阵表示法3、有向图的邻接矩阵表示法4、网（有权图）的邻接矩阵表示法5、邻接矩阵的存储表示6、采用邻接矩阵表示法创建无向网7、邻接矩阵优点和缺点 图没有顺序存储结构，但可以借助二维数组来表示元素之间的关系，即邻接矩阵表示法 图的链式存储结构有多种，邻接表、十字链表、邻接多重表 邻接矩阵、邻接表是我们重点要研究的 邻接矩阵 1、邻接矩阵表示法 建立...
无向图的邻接矩阵与邻接表详细实现
code_peak
07-16 1万+
无向图的邻接矩阵 通过用邻接矩阵来表示无向图。如下无向图G1的邻接矩阵： 无向图G1包含了“A, B, C, D, E, F, G”共七个顶点，而且包含了“(A, C), (A, D), (A, F), (B, C), (C, D), (E, G), (F, G)”共七条边。由于这是无向图，所以(A, C)和(C, A)是同一条边，这里列举边时，按照字母先后顺序列举的。 无向图G1右边的邻接矩阵在内存中的邻接矩阵示意图。A[i][j] = 1表示第i个顶点与第j个顶点是邻接点，A[i][j] = 0表示它
无向图的表示：邻接矩阵和邻接表
x_i_y_u_e的专栏
06-14 2万+
这里将一个无向图用邻接表和邻接矩阵表示。 输入：顶底个数n，图中的各个边（用两个顶点表示）。 输出：这个无线图的邻接矩阵和邻接表，其中邻接表中的链接按元素大小升序排列。 先给出一个例子说明。假设有无向图如下，则其邻接矩阵和邻接表如提示框中所示（其实就是下面程序的输出）。 下面是程序的代码： #include #include //图的表示，输入节点个数和边，构造图的邻接矩阵
无向图G的邻接矩阵法和邻接表法以及遍历输出无向图G包括两种存储的FirstNeighbor和NextNeighbor两种基本操作
最新发布
m0_75220252的博客
06-26 3398
无向图G的邻接矩阵法和邻接表法以及遍历输出无向图G包括两种存储的FirstNeighbor和NextNeighbor两种基本操作
图的表示——邻接表与邻接矩阵
G_H010的博客
09-21 1570
图的表示方法——邻接表与邻接矩阵
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
在压缩包文件"数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历_1602077415"中，包含了关于这些主题的详细资料，可能包括理论解释、代码示例和练习题，帮助读者深入理解和掌握图的存储...
邻接表或者邻接矩阵为存储结构实现连通无向图的深度优先和广度优先遍历
12-06
程序设计任务： 设计一个程序，实现以邻接表或者邻接矩阵为存储结构，实现连通无向图的深度优先和广度优先遍历。基本要求：以邻接表或者邻接矩阵为存储结构，实现连通无向图的深度优先和广度优先遍历。以用户指定的...
基于java数据结构实验基于邻接矩阵和邻接表的深度广度优先遍历图.pdf
12-19
基于Java数据结构实验基于邻接矩阵和邻接表的深度广度优先遍历图 本实验报告的主要内容是基于Java数据结构实验，实验名称为“基于邻接矩阵和邻接表的深度广度优先遍历图”。实验的目的包括掌握图的相关概念、掌握用...
C++实现图的邻接矩阵存储和广度、深度优先遍历实例分析
09-03
在C++编程中，处理图的数据结构通常涉及两种主要的存储方法：邻接矩阵和邻接表。本实例重点讨论了邻接矩阵的实现，并展示了如何进行广度优先遍历(BFS)和深度优先遍历(DFS)。邻接矩阵是一种二维数组，其中的每个元素...
图【数据结构】
m0_73065213的博客
05-28 1188
图的抽象数据类型定义如下：ADT Graph数据对象V：具有相同特性的数据元素的集合，称为顶点集。数据关系R：R={VR}VR={＜v，w＞表示从v到w的弧，P（v，w）定义了弧＜v，w＞的信息基本操作P：：图的创建操作。初始条件：无。操作结果：生成一个没有顶点的空图G。：求图中的顶点v的值。初始条件：图G存在，v是图中的一个顶点。操作结果：生成一个没有顶点的空图G。初始条件：V是图的顶点集，VR是图中弧的集合。操作结果：按V和VR的定义构造图G。
数据结构之图（邻接矩阵、邻接表、邻接多重表、十字链表；深度优先搜索、广度优先搜素；最短路径、关键路径、拓扑排序、最小生成树）
qq_43752469的博客
10-07 3429
一、图的知识框架 二、图的定义 图：图G由顶点集V和边集E组成，记为G=(V,E)，其中V(G)表示图G中顶点的有限非空集；E(G)表示图G中顶点之间的关系(边)的集合。 1.有向图 若E是有向边（简称弧）的有限集合时，则G为有向图。弧是顶点的有序对，记为<v,w>，其中 v，w 是顶点，v 是弧尾，w 是弧头。称为从顶点v到顶点w的弧。 G1可表示为： G=(V,E) V={1,2,3} E={<1,2>, <2,1>, <2,3>} 2.无向图 若E是
利用邻接矩阵进行的深度优先和广度优先遍历（含全部代码+图解）
热门推荐
Initial_Mind的博客
04-29 3万+
良苦用心
无向图的邻接矩阵的深度优先搜索和广度优先搜索（C++实现）
爱玲姐姐的博客
01-30 6068
一、深度优先搜索 深度优先搜索遍历类似于树的先根遍历，是树的先根遍历的推广。其过程为：假设初始状态是图中所有顶点未曾被访问，则深度优先搜索可以从图中的某个顶点v出发，访问此顶点，然后依次从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v有路径相通的顶点都被访问到；若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作为起始点，重复上述过程，直至图中所有顶点都被访问到为止。 1. ...
图的邻接矩阵、邻接表存储和图的广度优先搜索（BFS）、深度优先搜索（DFS）
Dong_HFUT的博客
04-10 7650
图的邻接矩阵和邻接表表示。广度优先搜索（BFS）、深度优先搜索（DFS）及 C++ 实现。
深度优先算法和广度优先算法
08-26 3937
在数据结构中，树和图可以说是不可或缺的两种数据结构。其中，对于图来说，最重要的算法可以说就是遍历算法。而搜索算法中，最标志性的就是深度优先算法和广度优先算法。图的定义普遍为两种，一种是邻接表，另一种是邻接矩阵。图的邻接矩阵表示是唯一的，但对于邻接表来说，若边的输入次序不同生成的邻接表也不同。因此，对于同一个表，基于邻接矩阵的遍历所得到的BFS序列和DFS序列是不唯一的，基于邻接表的遍历所得到的BFS和DFS是唯一的。...
邻接表-数组实现+深搜广搜（超详细）
qq_41884068的博客
05-16 1721
图的邻接表存储与访问数组实现算法分析 图的存储结构有两种，基于数组的邻接矩阵存储和基于链表的邻接表存储。邻接矩阵存储比较容易实现，但需要很大的内存来存储，访问的时间复杂度高。基于链表的邻接表时间复杂度和空间复杂度比前者要小，但是难于实现。邻接表的数组实现方法综和了以上两种存储方法的优点，在时间复杂度和空间杂度上更优，并且易于理解和实现。 图的邻接矩阵存储，时间复杂度为o（n2),n是图中结点的个数...
无向图（无权值）的邻接矩阵与邻接表储存方式及其DFS，BFS遍历
Specif1c的博客
11-26 7415
求下图中无向图的邻接矩阵与邻接表储存方式及其DFS，BFS遍历 一、 无向图（无权值）的邻接矩阵存储方式及其DFS，BFS遍历 邻接矩阵的储存表示： 广度优先遍历需要用到队列操作，因此还需要定义一下队列的存储结构 具体代码： #include <stdio.h> #define MaxVex 100 //最大顶点数 #define TRUE 1 #define FALSE 0 typedef char VertexType;
南工大第四章-图.pdf
01-31
本资源是南京工业大学第四章关于图论的课程资料，涉及了数据结构与算法中的重要概念和基础知识。主要内容包括： 1. 图的基本概念：讨论了无向图和有向图中顶点度数的关系，指出在一个无向图中，所有顶点的度数之和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

土味儿~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值