408数据结构学习笔记——图的广度优先搜索、深度优先搜索

最新推荐文章于 2024-05-09 11:45:55 发布
最新推荐文章于 2024-05-09 11:45:55 发布
阅读量1.9k 收藏 19
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 图搜索算法 深度优先遍历 广度优先 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JiangNan_1002/article/details/124040896
版权

目录

1.广度优先搜索

1.1.广度优先搜索的概念

1.2.广度优先搜索的可变性

1.3.广度优先搜索性能

2.深度优先搜索

2.1.深度优先搜索的概念

2.2.深度优先搜索的性能

3.图的遍历和图的连通性

4.王道课后题

1.广度优先搜索

1.1.广度优先搜索的概念

广度优先搜索(Breadth-First-Search, BFS)，类似二叉树层次遍历。以v为起点，依次访问和v有路径相同且路径长度为1，2，……的顶点

#define MaxVertexNum 100

bool visited[MaxVertexNum];    //标记是否访问过

void BTS(Graph G, int v){    //从顶点v出发
    Queue Q;
    initQueue(Q);
    visit(v);    //访问v
    visited[v] = true;    //visited数组中下标v的元素改为true
    EnQueue(Q, v);    //v入队
    while(!IsEmpty(Q)){
        DeQueue(Q, v);    //取出队头元素
        int w;
        for(w = FirstNeighbor(G, v); w >= 0; w = NextNeighbor(G, v, w)){
            //检测所有v的邻接点
            if (!visit[w]){    //w当前未访问过
                visit(w);    //访问w
                visit[w] = true;    //visited数组中下标w的元素改为true
                EnQueue(Q, w);    //将w入队
            }//if
        }//for
    }//while
}

非连通图或非强连通图，在执行完BTS后，可能还会有剩余的顶点没有访问到，因此，要重新调用BTS函数继续进行遍历

bool visited[MaxVertexNum];

void BTS(Graph G, int v){
    visit(v);
    visited[v] = true;
    Queue Q;
    InitQueue(Q);
    EnQueue(Q, v);
    while(!IsEmpty(Q)){
        DeQueue(Q, v);
        int w;
        for (w = FirstNeighbor(G, v); w >= 0; w = NextNeighbor(G, v, w)){
            if (!visited[w]){
                visit(w);
                visited[w] = true;
                EnQueue(Q, W);
            }//if
        }//for
    }//while
}

void BTS_G(Graph G){
    for (int i = 0; i < G.verNum; i++) visited[i] = false;    //初始化visited数组
    //当前visited数组下标i的元素为false，调用BTS函数
    for (int i = 0; i < G.verNum; i++) if (!visited[i]) BTS(G, i);
}

1.2.广度优先搜索的可变性

邻接矩阵唯一→广度优先遍历序列唯一

邻接表不唯一→广度优先遍历序列不唯一

1.3.广度优先搜索性能

空间复杂度：图中每个顶点都需要入队一次，最坏情况下是O(|V|)

时间复杂度：分为访问各顶点的时间和探索各条边的时间

  1. 邻接矩阵，访问V个结点，需要O(|V|)，查找需遍历V行（顶点数），每行V个顶点，需要O(|V^{2}|)，故时间复杂度为O(|V^{2}|)
  2. 邻接表，访问V个结点，需要O(|V|)，查找E个边，需要O(|E|)，故时间复杂度为O(|V|+|E|)

2.深度优先搜索

2.1.深度优先搜索的概念

首先访问起点v，然后访问与之邻接且未被访问的顶点w，再访问与w邻接且未被访问的顶点u，直到不能再继续向下访问时，依次退回到最近被访问的顶点，如果还有邻接且未被访问的顶点，则访问那个顶点，循环这个过程，直至图中所有顶点都被访问过

bool visited[MaxVertexNum];

void DFS(Graph G, int v){
    visit(v);
    visited[v] = true;
    int w;
    for (w = FirstNeighbor(G, v); w >= 0; w = NextNeighbor(G, v, w)) DFS(G, w);
}

void DFS_G(Graph G){
    for (int i = 0; i < G.verNum; i++) visit[i] = false;
    for (int i = 0; i < G.verNum; i++) if (!visit[i]) DFS(G, i);
}

2.2.深度优先搜索的性能

空间复杂度：最好O(1)：中间一点连着其他顶点，栈仅需一个空间；最坏O(|V|)：一条线，需要全部依次压入栈中

时间复杂度：

  1. 邻接矩阵 O(|V^{2}|)
  2. 邻接表O(|V|+|E|)

3.图的遍历和图的连通性

无向图：DFS/BFS函数调用次数 = 连通分量数

有向图：起始顶点到其他顶点都有路径，则仅需一次；强连通图从任意一个顶点出发，都仅需一次

4.王道课后题

 无向图是树→连通图且没有回路 || 有 n - 1 条边的连通图

//广度搜索，对应连通图且没有回路
bool visited[MaxVertexNum];

bool IsTree(ALGraph G) {
	//初始化visited数组
	for (int i = 0; i < MaxVertexNum; i++) visited[i] = false;
	Queue Q;
	InitQueue(Q);
	//寻找图中的第一个数据
	int p;
	for (p = 0; p < MaxVertexNum; p++) if (G.vertices[p].data) break;
    int temp = p;
    int count = 0;    //标记访问了多少个顶点
	//将p入队
	EnQueue(Q, p);
	while (!IsEmpty(Q)) {
		//出队队头元素
		DeQueue(Q, p);
		//当前顶点p未扫描过，则进入标记扫描，并且找到所有与它邻接的顶点，并依次入队
		if (!visited[p]) {
			visited[p] = true;
            count++;
			for (int q = FirstNeighbor(G, p); q >= 0; q = NextNeighbor(G, p, q)){
                EnQueue(Q, q);
            }
		}
		//扫描过p，存在回路
		else return false;
	}
    //访问顶点个数不等于顶点总数，非连通图
    if (count != G.verNum) return false;
    else return true;
}
//DFS，对应有 n - 1 条边的连通图
bool visited[MaxVertexNum];

bool IsTree(ALGraph G) {
	//初始化visited数组为false
	for (int i = 0; i < G.verNum; i++) visited[i] = false;
	//vCount记录遍历顶点数，eCount记录遍历边数
	int vCount = 0, eCount = 0;
	//遍历G中的每个顶点
	for (int i = 0; i < G.verNum; i++) {
		if (!visited[i]) DFS(G, vCount, eCount, i);
	}
	//满足条件顶点数=已遍历顶点数，并且边数为n - 1
	//无向图的存储中每条边存储两次
	if (vCount == G.verNum && 2 * eCount + 2 == G.arcNum) return true;
	else return false;
}

void DFS(ALGraph G, int& vCount, int& eCount, int v) {
	if (!visited[v]) {
		visited[v] = true;
		//访问顶点数+1
		vCount++;
	}
	for (int w = FistNeighbor; w >= ; w = NextNeighbor) {
		//访问边数+1
		eCount++;
		DFS(G, vCount, eCount, w);
	}
}

#define MaxVertexNum 100

typedef struct ArcNode{
    struct ArcNode *next;
    int adjVertex;
}ArcNode;

typedef struct VNode{
    ArcNode *next;
    elemtype data;
}VNode, adjList[MaxVertexNum];

typedef struct{
    adjList vertices;
    int verNum, arcNum;
}ALGraph;

typedef struct Stack{
    int top;
    elemtype data[MaxVertexNum];
}Stack;

bool visited[MaxVertexNum];

void DFS(ALGraph G, int v){
    //初始化visited数组
    for (int i = 0; i < MaxVertexNum; i++) visited[i] = false;
    Stack S;
    InitStack(S);
    int i, j;
    //访问v，并将v压入栈中
    visited[v] = true;
    push(S, v);
    //循环直到栈空
    while(!IsEmpty(S)){
        //弹出栈顶元素
        pop(S, i);
        //访问i所有的邻接结点
        for (j = FirstNeighbor(G, i); j >= 0; j = NextNeighbor(G, i, j)){
            //将j压入栈中
            if (!visited[j]) {
                visited[j] = true;
                push(S, j);
            }
        }//for
    }//while
}

//广度搜索
#define MaxVertexNum 100

typedef struct ArcNode{
    struct ArcNode *next;
    int adjVertex;
}ArcNode;

typedef struct VNode{
    ArcNode *first;
    elemtype data;
}VNode, AdjList[MaxVertexNum];

typedef struct ALGraph{
    AdjList vertices;
    int verNum, arcNum;
}ALGraph;

typedef struct Queue{
    elemtype data[MaxVertexNum];
    int rear, front;
}Queue;

bool visited[MaxVertexNum];
bool BFS_iToj(Graph G, int i, int j){
    for (int i = 0; i < G.verNum; i++) visited[i] = false;
    Queue Q;
    InitQueue;
    EnQueue(Q, i);
    int w, v;
    while (!IsEmpty(Q)){
        DeQueue(Q, v);
        if (!visited[v]) {
            //v == j， ij存在路径，返回true
            if (j == v) return true;
            visited[v] = true;
            for (w = FistNeighbor(G, v); w >= 0; w = NextNeighbor(G, v, w)){
                if (!visited[w]) EnQueue(Q, w);
            }
        }//if
    }//while
    //ij没有路径，返回false
    return false;
}
//深度搜索
#define MaxVertexNum 100

typedef struct ArcNode{
    struct ArcNode *next;
    int adjVertex;
 }ArcNode;

typedef struct VNode{
    ArcNode *first;
    elemtype data;
}VNode, AdjList[MaxVertexNum];

typedef struct ALGraph{
    int verNum, arcNum;
    AdjList vertices;
}ALGraph;

typedef struct Stack{
    elmetpye data[MaxVertexNum];
    int top;
}Stack;

bool visited[MaxVertexNum];

bool DFS_iToj(ALGraph G, int i, int j){
    Stack S;
    InitStack(S);
    for (int temp = 0; temp < G.verNum; temp++) visited[temp] = false;
    push(S, i);
    visited[i] = 0;
    int v, w;
    while (!IsEmpty(S)){
        pop(S, v);
        for (w = FirstNeighbor(G, v); w >= 0; w = NextNeighbor(G, v, w)){
            //w == j, ij存在路径，返回true
            if (w == j) return true;
            if (!visited[w]) {
                visited[w] = true;
                push(S, w);
            }
        }//for
    }//while
    return false;
}
江南江南江南丶
关注
  • 1
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构之图的广度优先搜索
bbewx的专栏
05-11 2005
遍历原则： 从图中指定的
秋招算法笔记集合（深度学习机器学习数据结构等）.zip
09-06
《秋招算法笔记集合》是一份综合性的学习资源，涵盖了深度学习、机器学习以及数据结构等多个领域的精华内容。这份资料的目的是帮助准备秋季招聘的求职者们系统地复习和掌握必要的算法知识，以应对面试中的各类挑战。...
图的广度优先搜索
吃葡萄不吐葡萄皮
12-17 1209
图的广度优先搜索
图的遍历（深度优先和广度优先）
2302_77758423的博客
05-09 1652
相比于树结构的遍历，图的遍历要复杂得多，因为图中的任何一个节点都可能与其它所有节点相邻接。这就意味着，在访问了某个节点之后，可能会顺着某条路径再次返回到这个节点。为了防止对节点进行重复访问，在图的遍历过程中需要记录下已经访问过的节点。深度优先搜索（DFS）和广度优先搜索（BFS）是两种基本的图遍历方法。DFS更适合深入挖掘问题的解决方案，而BFS则适用于逐层分析问题，寻找最短路径或按层次顺序进行操作。
数据结构—图的广度优先搜索
Miss Z的博客
09-11 1450
图的存储及基本操作
6.1 图的深度优先和广度优先搜索
weixin_30784945的博客
07-14 91
图的广度优先搜索 图的的搜索算法主要分为广度优先搜索(breadth-firstsearch或BFS)和深度优先搜索(depth-firstsearch或DFS)。首先讨论广度优先搜索算法。 称之为广度优先，是因为算法始终首先发现距离起始顶点较近的顶点，然后才发现较远的顶点。假设搜索的出发顶点为s，则首先搜索与s直接相邻的顶点，然后再搜索这些相邻顶点的相邻顶点。在搜索过程中可以记录每个...
数据结构之图
The_yja_of_Oier的博客
07-11 410
定义 图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个事物间具有这种关系。 用法 ...
《数据结构高分笔记》八九章习题.zip
01-30
在这一章中，可能会讲解图的邻接矩阵和邻接表两种表示方法，以及深度优先搜索(DFS)和广度优先搜索(BFS)这两种图的遍历算法。此外，路径查找、最小生成树（例如Prim算法和Kruskal算法）以及最短路径问题（如Dijkstra...
《数据结构——C++实现》（第二版）课本源代码.zip
最新发布
06-16
图算法如深度优先搜索（DFS）和广度优先搜索（BFS）在路径寻找、网络路由等领域有广泛应用。 7. **排序与查找算法**：排序如快速排序、归并排序、堆排序等，查找如二分查找、哈希查找等，都是数据结构中的关键概念...
《Java数据结构和算法》学习笔记(3)——栈和队列
03-14
本文将基于《Java数据结构和算法》学习笔记中的“栈和队列”部分进行深入探讨。 栈（Stack）是一种线性数据结构，遵循后进先出（LIFO, Last In First Out）的原则。在栈中，元素的添加（压栈）和移除（弹栈）都是在...
【数据结构】图的广度优先搜索
weixin_30765319的博客
08-29 78
　　图的广度优先搜索（BFS）与树的广度优先搜索类似。与树不同的是，图中可能存在循环。所我们可能会再次访问到同一个节点。为了表面多次处理同一个节点，我们要布尔变量数据记录节点有没有被访问过。为了简化，我们假设所有的节点都是从根节点可达的。 　　比如在下图中，我们从节点2出发。当我们访问到节点0时，我们寻找所有与他相邻的节点。节点2就是与0相邻的节点，如果我们不对已访问的节点做标记，那么节点2就会...
图的深度优先搜索
HMT的博客
10-29 152
图的深度优先搜索 算法描述 找一个未被访问过的结点v0v_0v0​，并访问它 找到该节点一个未被访问过的相邻结点v1v_1v1​，并访问v1v_1v1​，再找v1v_1v1​未被访问过的相邻结点。 重复2，直到某个结点vxv_xvx​没有未被访问过的相邻结点，这时退回上一个访问的结点再重复2，直到访问完v0v_0v0​的所有相邻结点 若此时仍有未被访问过的结点，重复1 设计思维 可以给每个结点一个序号，然后创建一个相应长度的数组，初始化为全0数组，该数组索引代表结点序号，内容表示结点是否被访问过。若访
软考程序员数据结构学习笔记
"软考程序员数据结构笔记.doc 是一份针对软考程序员考试的详细学习资料，涵盖了数据结构的基础知识，包括线性结构、树形结构、集合以及数组、顺序表、字符串、特殊矩阵和稀疏矩阵等概念。文档还强调了分析问题、设计...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值