图的邻接矩阵、邻接表存储和图的广度优先搜索（BFS）、深度优先搜索（DFS）

已于 2022-04-26 10:57:33 修改
阅读量7.8k 收藏 80
点赞数 19
分类专栏： 数据结构和算法 文章标签： 数据结构 算法 深度优先搜索 广度优先搜索 BFS
于 2022-04-10 14:31:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dong_HFUT/article/details/124068576
版权

图的邻接矩阵、邻接表存储和图的广度优先搜索（BFS）、深度优先搜索（DFS）

本文将先介绍图的存储方式：邻接矩阵和邻接表，接着介绍图的基本算法：广度优先搜索和深度优先搜索。

图及其存储方式

图是一种非线性的数据结构。在图论中，图是一种数学结构，用来表示一组对象，这些对象之间有一些成对的关系。对象可以包含任意信息，例如单个值、某段代码或公司员工的姓名，具体取决于图的用途。

这里我们尽可能简单地用一个字母标识每个对象，将图中对象称为顶点(vertices)，对象间关系称为边(edges)。使用 G = ( V , E ) G = (V,E) G=(V,E) 描述顶点V 和边E 的集合，顶点V 的个数为 n = ∣ V ∣ n = |V| n=∣V∣，边的个数 m = ∣ E ∣ m = |E| m=∣E∣。

边用于描述顶点的移动，这种移动称为路径，边可以是有方向的，也可以是无方向的。也就是说，通过多个顶点到顶点的边，可能从顶点y到达顶点v。图中y到v的路径可以记为： y   ∗ → G   v _y \ \underrightarrow{*}_G\ {_v} y​  ∗​G​ v​ 。图可以有一个根节点r，表示图的起点，这时候图记为 G = ( V , E , r ) G=(V,E,r) G=(V,E,r)。
在这里插入图片描述

  • 度（Degree）：在无向图中，用于表示一个顶点有多少条边。在有向图中，又把度分为入度（In-Degree）和出度（Out-Degree）。
  • 入度：表示有多少条边指向一个顶点
  • 出度：表示有多少条边从这个顶点指向其他顶点。

一般会使用邻接矩阵（Adjacency Matrix）和邻接表（Adjacency List）两种方式存储图。
在这里插入图片描述

  • 邻接矩阵：邻接矩阵是一种比较直观的存储方式，使用一个二维数组 Adj[i][j] 。对于无向图，若顶点 i 和 j 之间存在边，则 Adj[i][j] 和 Adj[j][i] 的值为 1；对于有向图，若顶点 i 和 j 之间存在由顶点 i 指向 j 的边，则 Adj[i][j] 的值为 1。若图的边有权值，则数组中存入权值即可。
  • 邻接表：使用链表数组 Adj[N] 来存储，每个顶点使用一个链表，数组大小 N 为顶点个数。Adj[u] 表示所有和顶点 u 相连的节点。

在这里插入图片描述

这里直接使用算法导论上的原图。邻接矩阵和连接表的优缺点也非常明显。邻接矩阵的优点是比较直观，两个顶点的关系比较容易计算，缺点是比较浪费存储空间，尤其对于稀疏图。而邻接表的优点是比较节省存储空间，而缺点是两个顶点的关系计算相对比较困难一些。实际应用需要根据场景和需求选择合适的存储方式。

邻接矩阵存储的参考代码：

#define MaxVertexNum 10
typedef char VertexType;
typedef int EdgeType;

typedef struct
{
    VertexType vertex[MaxVertexNum];
    EdgeType edge[MaxVertexNum][MaxVertexNum];
    int vexnum, edgenum;
} AdjMatGraph;

邻接表参考代码：

#define MaxVertexNum 100
typedef char VertexType;
typedef int EdgeType;

typedef struct Edge{
	int adjvex;	        //边指向的顶点的位下标
	EdgeType weight;    //权值
	struct Edge *next;	//指向下一个邻接点
}Edge;

typedef struct Vertex{
	VertexType value;  //顶点信息
	Edge *firstedge;   //边指针
}Vertex, AdjList[MaxVertexNum];

typedef struct{
	AdjList adjList;
	int vexnum, edgenum;
}AdjListGraph;

如果你的图没有权值，顶点信息比较简单，也可以直接使用 C++ 的 vector 表示：

std::vector<std::vector<int>> graph;

广度优先搜索

广度优先搜索（BFS：Breadth-first search）是从源节点到达所有节点，并且从已发现节点搜索未发现节点的时候，始终是从已发现节点的广度方向展开，这优点类似树的层次遍历。BFS 算法生成以源节点 s 到达所有节点 v 的一棵广度优先搜索树。
在这里插入图片描述
借助队列，BFS 算法流程如上图所示。以邻接表存储为例，给出 BFS 的算法：

bool visited[MaxVertexNum];
void BFS(const AdjListGraph& g) {
    for (int i = 0; i < g.vexnum; i++) {
        visited[i] = false;
    }
    queue<int> q;
    for (int i = 0; i < g.vexnum; i++) {  // 防止存在非联通子图
        if (!visited[i]) {
            visited[i] = true;
            // visit
            cout << g.adjList[i].value;
            q.push(i);
            while (!q.empty()) {
                int u = q.front();
                q.pop();
                for (Edge* edge = g.adjList[u].firstedge; edge != nullptr; edge = edge->next) {
                    if (!visited[edge->adjvex]) {
                        // visit
                        cout << g.adjList[edge->adjvex].value;
                        visited[edge->adjvex] = true;
                        q.push(edge->adjvex);
                    }
                }
            }
        }
    }
    cout << endl;
}

深度优先搜索

深度优先搜索（DFS：Depth-first search）尽可能深地搜索一个图。首先访问其实一个起始节点 v，然后访问 v 的一个邻接节点 w， 接着 w 的邻接节点。重复上述过程，当无法继续访问时，则回退到最近访问的节点，继续上述过程，直到所有节点都被访问过。

DFS 算法的递归方式比较简单：

bool visited[MaxVertexNum];
void dfs(const AdjListGraph& g, int u) {
    // visit
    cout << g.adjList[u].value;
    visited[u] = true;
    for (Edge* edge = g.adjList[u].firstedge; edge != nullptr; edge = edge->next) {
        if (!visited[edge->adjvex]) {
            dfs(g, edge->adjvex);
        }
        
    }
}
void DFS(const AdjListGraph& g) {
    for (int i = 0; i < g.vexnum; i++) {
        visited[i] = false;
    }
    for (int i = 0; i < g.vexnum; i++) { // 防止存在非联通子图
        if (!visited[i]) {
            dfs(g, i);
        }
    }
}

最后，附上本文源码，方便大家验证。

#include<iostream>
#include<queue>
#include<memory>

using namespace std;

#define MaxVertexNum 100
typedef char VertexType;
typedef int EdgeType;

typedef struct Edge{
	int adjvex;	        //边指向的顶点的位下标
	// EdgeType weight;    //权值
	struct Edge *next;	//指向下一个邻接点
}Edge;

typedef struct Vertex{
	VertexType value;  //顶点信息
	Edge *firstedge;   //边指针
}Vertex, AdjList[MaxVertexNum];

typedef struct{
	AdjList adjList;
	int vexnum, edgenum;
}AdjListGraph;

// lookup index of vertex u in the graph
int LocateVex(const AdjListGraph& g, VertexType u)
{
    int i;
    for(i = 0; i < g.vexnum; ++i)
        if(u == g.adjList[i].value)
        {
            return i;
        }
            
    return -1;
}

void printGraph(const AdjListGraph& g)
{
    for(int i = 0; i < g.vexnum; i++)
    {
        cout << g.adjList[i].value;
        Edge* edge = g.adjList[i].firstedge;
        while(edge != nullptr)
        {
            cout << "->" << g.adjList[edge->adjvex].value;
            edge = edge->next;
        }
        cout << endl;
    }
}

void deleteGraph(AdjListGraph& g) {
    // TODO
}

void createGraph(AdjListGraph &g) {
    cout << "Enter vertex num: ";
    cin >> g.vexnum;
    cout << "Enter edge num: ";
    cin >> g.edgenum;
    
    cout << "Enter " << g.vexnum << " vertex value: ";
    for (int i = 0; i < g.vexnum; i++) {
        cin >> g.adjList[i].value;
        g.adjList[i].firstedge = nullptr;
    }
    
    cout << "Enter" << g.edgenum << " edge info:" << endl; 
    for (int e = 0; e < g.edgenum; e++) {
        VertexType v1, v2;
        cin >> v1 >> v2;
        int i = LocateVex(g, v1);
        int j = LocateVex(g, v2);
        if (i == -1 || j == -1) {
            cout << "Error edge info" << endl;
        }
        
        Edge* e1 = new Edge();
        e1->adjvex = j;
        e1->next = g.adjList[i].firstedge;
        g.adjList[i].firstedge = e1;
        
        Edge* e2 = new Edge();
        e2->adjvex = i;
        e2->next = g.adjList[j].firstedge;
        g.adjList[j].firstedge = e2;       
    }
}


bool visited[MaxVertexNum];
void BFS(const AdjListGraph& g) {
    for (int i = 0; i < g.vexnum; i++) {
        visited[i] = false;
    }
    queue<int> q;
    for (int i = 0; i < g.vexnum; i++) {
        if (!visited[i]) {
            visited[i] = true;
            // visit
            cout << g.adjList[i].value;
            q.push(i);
            while (!q.empty()) {
                int u = q.front();
                q.pop();
                for (Edge* edge = g.adjList[u].firstedge; edge != nullptr; edge = edge->next) {
                    if (!visited[edge->adjvex]) {
                        // visit
                        cout << g.adjList[edge->adjvex].value;
                        visited[edge->adjvex] = true;
                        q.push(edge->adjvex);
                    }
                }
            }
        }
    }
    cout << endl;
}

void dfs(const AdjListGraph& g, int u) {
    // visit
    cout << g.adjList[u].value;
    visited[u] = true;
    for (Edge* edge = g.adjList[u].firstedge; edge != nullptr; edge = edge->next) {
        if (!visited[edge->adjvex]) {
            dfs(g, edge->adjvex);
        }
        
    }
}

void DFS(const AdjListGraph& g) {
    for (int i = 0; i < g.vexnum; i++) {
        visited[i] = false;
    }
    for (int i = 0; i < g.vexnum; i++) {
        if (!visited[i]) {
            dfs(g, i);
        }
    }
}

int main () {
    AdjListGraph g;
    createGraph(g);
    printGraph(g);
    BFS(g);
    DFS(g);
    deleteGraph(g);
}

reference:

  • 算法导论
  • https://blog.51cto.com/u_15346415/3674106
loongknown
关注
专栏目录
邻接矩阵/图/DFS/BFS
m0_61548909的博客
06-06 2179
目录1.邻接矩阵的表示2.邻接矩阵的存储3.采用邻接矩阵表示法创建无向网 4.基于邻接矩阵的图上各类操作 5.DFS6.BFS7.测试程序（待完成） 权与网连通分量（强连通分量） 无向图 有向图 网（有权图） 3.采用邻接矩阵表示法创建无向网 创建无向图和有向图的区别 优缺点 声明 广度优先搜索需要的队列（图的遍历） 基于邻接矩阵的图上操作 5.DFS 深度优先搜索属于图算法的一种，是一个针对图和树的遍历算法，英文缩写为DFS即Depth First Search。深度优先搜
分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历_图的BFS、DFS
weixin_39527768的博客
11-23 4265
BFS、DFS分别为广度优先搜索和深度优先搜索的英文首字母缩写。先考虑树的BFS、DFS。树的BFS即层序遍历。层序遍历先访问根结点，再逐个访问根结点的子结点，再逐个访问上述子结点的子结点，以此类推，直至访问过所有结点。树的DFS有三种（先序遍历、中序遍历、后序遍历），这里只说先序遍历。先序遍历先访问根结点，再逐个先序遍历根结点的所有子树。（由递归的定义可知，容易用递归算法实现（函数的递归用到了调...
求图的最短路径（迪杰斯特拉算法）
戒
12-04 385
#include <stdio.h> #include<string.h> #include<stdlib.h> #include<time.h> const int Len=105; const int INF =99999; typedef struct Node{ int nv;//点 int ne;//边 int data[Len][Len]; int visited[Len]; }*graph;//图 grap
数据结构—图之邻接表
Gloria971111的博客
11-18 1072
尾插法建立邻接表，效率没有前插法高，但是可以去重#include<iostream> using namespace std; #include<string.h> #define MVNum 100typedef struct ArcNode { int adjvex;//该边所指向的顶点的位置 ArcNode *nextarc;//指向下一条边的指针 int info
邻接矩阵 BFS
u012342878的专栏
10-13 899
#include #include #include #include #include #include #include using namespace std; const int sizen=10000; int Map[sizen][sizen]; bool mark[sizen]; void BFS(int x,int n) {     int
数据结构与算法：30张图弄懂“图的两种遍历方式”
AI科技大本营
04-03 5465
点击上方↑↑↑蓝字关注我们~「2019 Python开发者日」全日程揭晓，请扫码咨询 ↑↑↑作者 | 程序员吴师兄转载自五分钟学算法（ID:CXYxiaowu）1 引言遍...
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
本主题将深入探讨图的两种常见存储方式——邻接矩阵和邻接表，以及如何进行深度优先搜索（DFS）和广度优先搜索（BFS）遍历。 **邻接矩阵**是一种直观且简单的图存储方法。对于一个有n个顶点的图，邻接矩阵是一个n×...
邻接表或者邻接矩阵为存储结构实现连通无向图的深度优先和广度优先遍历
12-06
- `DFS(ALGraph G, int v)`和`BFS(ALGraph G, int v)`分别执行深度优先和广度优先遍历，输出访问序列。 - 边集的输出函数`DFSB(ALGraph G, int v)`和`BFSB(ALGraph G, int v)`记录遍历过程中形成的边。 7. **测试...
图的邻接表与邻接矩阵的-深度优先搜索（dfs）与广度优先搜索（bfs）
weixin_64687170的博客
02-08 435
是从图的某一顶点出发，按照某种搜索方式对图中所有顶点访问一次且仅一次。图的遍历可以解决很多搜索问题，在实际中应用非常广泛。图的遍历根据搜索方式的不同，分为广度优先搜索和深度优先搜索。
DFS（邻接矩阵）
戒
12-04 626
#include <stdio.h> #include<string.h> #include<stdlib.h> #include<time.h> const int Len=105; typedef struct SNode* Stack; struct SNode { int data; struct SNode* next; };//栈 typedef struct Node{ int nv;//点 int ne;//边 i
邻接矩阵BFS(广度优先遍历)算法数据结构c语言
2302_80479160的博客
06-01 230
这里用队列辅助，输出结果有一定的顺序,深度优先遍历和广度优先遍历有连通和不连通两种，对于无向图来说，若是连通图，则一次遍历能够访问到图中所有的顶点，若无向图是非连通图，则只能访问到初始点所在连通分量中的所有顶点，其它连通分量是不可能访问到的，为此需要从其它每个连通分量中选择初始点，分别进行遍历，这样才能够访问到1图中的所有顶点，对于有向图来说，若从初始点到图中的每个顶点都有路径，则能够访问到图中的所有顶点，否则不能访问到所有顶点，为此需要再选择初始点，继续进行遍历，知道图中的所有顶点都被访问完为止。
图的广度优先遍历BFS(邻接矩阵表示法)
xwdreamer的专栏
06-13 4171
1.前言复习算法第四章——图中的路径，首先完成算法广度优先遍历，其中使用到了队列结构2.参考资料http://blog.csdn.net/lengyuhong/archive/2010/01/06/5145100.aspx3.相关博客在之前的博客中完成了图的深度优先遍历，也是使用邻接矩阵表示法。图的深度优先遍历(邻接矩阵表示法) 4.代码实现#inc
邻接表的BFS
Sugite
02-15 1093
import java.util.Arrays; import java.util.LinkedList; class Vertex { public char v;// vertex private LinkedList nextList = null;// 与v相邻的vertex集合 public int color;// 0:white 1:gray 2:black privat
【图的邻接矩阵、邻接表存储结构，深度优先和广度优先搜索遍历以及普里姆算法实现最小生成树可执行程序】
lflcodeplus的博客
12-12 8019
​要求1. 编程实现如下功能： （1）输入有向图的顶点数、边数及各条边的顶点对， 建立用邻接表存储的有向图。 （2）输出有向图的邻接表 （3）对有向图进行深度优先搜索和广度优先搜索遍历，并分别输出其遍历序列。 有向图如下所示： #include<iostream> #include<string.h> #include<iomanip> using namespace std; ​ #define ERROR 0 #define OK 1 #define MVNum 1
暑假训练总结
sdau20163940的博客
08-25 303
转眼之间，暑假一个月的时间就飞逝了。其实回过头来，你会发现时间过得真的很快，时间是抓不住的，关键是你如何利用时间，使有限的时间发挥最大的效率，提高时间的利用率。回过头，总结一下一个暑假的工作成果，其实也是一种收获。 首先，一进入假期我们就把精力投入到了DP上面，DP在ACM中非常重要的，同时又是竞赛中的难点，因为该算法时间效率高，代码量少，多元性很强，主要考察自己的思维能力和建模的抽象能力以及自
【C语言】数据结构——邻接矩阵的bfs dfs
最新发布
wheatbeat的博客
06-10 511
/图的类型（有向图，有向网，无向图，无向网）printf("请输入%d个节点(小于四个字符)的值，每个节点之间用‘ ’区分：",ptr->vernum);printf("请输入%d个节点(小于四个字符)的值，每个节点之间用‘ ’区分：",ptr->vernum);printf("请输入%d个节点(小于四个字符)的值，每个节点之间用‘ ’区分：",ptr->vernum);printf("请输入%d个节点(小于四个字符)的值，每个节点之间用‘ ’区分：",ptr->vernum);/*邻接表，要用的！
C++笔记-基于邻接矩阵的BFS（宽度优先遍历）
bai_Mou的博客
08-31 332
邻接表是是用一个二维链表，表示顶点和顶点相邻的节点。 而邻接矩阵是，他的行，代表的是顶点，列也代表的顶点，如下： 第0行：这是第0个顶点，他可以去第1个和第2个顶点； 第1行：这是第1个顶点，他可以去第4个顶点； 第2行：这是第2个顶点，他可以去第0个和第2和第3个顶点； 第3行：这是第3个顶点，他可以去第0个和第4个顶点； 第4行，这是第4个顶点，他一个顶点也不能走。 思路BFS都一样，先选一个顶点，然后看他可以访问哪个顶点，然后依次访问： 运行截图：先访问0这个顶点，在1，.
图——邻接表的DFS，BFS
卖核弹的小男孩 的博客
05-06 4637
邻接表做存储结构时，找邻接点所需的时间取决于顶点和边的数量，DFS，BFS时间复杂度为O(n+e)。 1、邻接表 2、邻接表 DFS： 从起点出发，走过的点要做标记，发现有没走过的点，就随意挑一个往前走，走不了就回退，此种路径搜索策略就称为“深度优先搜索”，简称“深搜”。其实称为“远度优先搜索”更容易理解些。因为这种策略能往前走一步就往前走一 步，总是试图走得更远。所谓远近(或深度），就是以...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值