宽度优先遍历（BFS）

最新推荐文章于 2023-05-09 19:52:03 发布
最新推荐文章于 2023-05-09 19:52:03 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 算法 文章标签： bfs 遍历 C语言 广度优先遍历
本文介绍使用邻接矩阵和邻接表两种方式实现广度优先搜索(BFS)算法的过程。通过C语言代码展示了如何创建图、打印图、进行广度优先遍历，并解释了队列操作及遍历相关节点的具体实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

BFS邻接矩阵描述

#include <stdio.h>  
#include <malloc.h>  
#define VERTEXNUM 5  

//队列的元素  
typedef struct qElement{  
        int value;  
        struct qElement* pre;  
        struct qElement* next;  
}st_qElement;  

//队列的前端和后端，最后一个入队列的元素为rear，第一个出队列的元素为front  
st_qElement* front = NULL;  
st_qElement* rear = NULL;  

void createGraph(int (*edge)[VERTEXNUM], int start, int end);  
void displayGraph(int (*edge)[VERTEXNUM]);  
void BFT(int (*edge)[VERTEXNUM],int* vertexStatusArr);  
void BFTcore(int (*edge)[VERTEXNUM],int i,int* vertexStatusArr);  
void putQueue(int vertex);  
int* getQueue();  
void putRelatedInQueue(int (*edge)[VERTEXNUM], int vertex);  

int main(void){  
        //动态创建存放边的二维数组   
        int (*edge)[VERTEXNUM] = (int (*)[VERTEXNUM])malloc(sizeof(int)*VERTEXNUM*VERTEXNUM);  
        int i,j;  
        for(i=0;i<VERTEXNUM;i++){  
                for(j=0;j<VERTEXNUM;j++){  
                        edge[i][j] = 0;  
                }  
        }  

        //存放顶点的遍历状态，0：未遍历，1：已遍历  
        int* vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);  
        for(i=0;i<VERTEXNUM;i++){  
                vertexStatusArr[i] = 0;  
        }  

        printf("after init:\n");  
        displayGraph(edge);  
        //创建图  
        createGraph(edge,0,3);  
        createGraph(edge,0,4);  
        createGraph(edge,3,1);  
        createGraph(edge,3,2);  
        createGraph(edge,4,1);  

        printf("after create:\n");  
        displayGraph(edge);  

        //广度优先遍历  
        BFT(edge,vertexStatusArr);  

        free(edge);  
        return 0;  
}  

//创建图  
void createGraph(int (*edge)[VERTEXNUM], int start, int end){  
        edge[start][end] = 1;  
}  

//打印存储的图  
void displayGraph(int (*edge)[VERTEXNUM]){  
        int i,j;  
        for(i=0;i<VERTEXNUM;i++){  
                for(j=0;j<VERTEXNUM;j++){  
                        printf("%d ",edge[i][j]);  
                }  
                printf("\n");  
        }  
}  

//广度优先遍历  
void BFT(int (*edge)[VERTEXNUM], int* vertexStatusArr){  
        printf("start BFT graph:\n");  
        int i;  
        for(i=0;i<VERTEXNUM;i++){  
                BFTcore(edge,i,vertexStatusArr);  
        }  
        printf("\n");  
}  

void BFTcore(int (*edge)[VERTEXNUM],int i,int* vertexStatusArr){  
        putQueue(i);  
        int* qeValue = NULL;  
        while((qeValue = getQueue()) != NULL){  
                if(vertexStatusArr[*qeValue] == 0){  
                        printf("%d ",*qeValue);  
                        vertexStatusArr[*qeValue] = 1;  
                        putRelatedInQueue(edge, *qeValue);  
                }  
                free(qeValue);  
                qeValue = NULL;  
        }  
}  

//将元素放到队列中  
void putQueue(int vertex){  
        st_qElement* qe = (st_qElement*)malloc(sizeof(st_qElement));  
        qe->value = vertex;  
        qe->next = NULL;  
        qe->pre = NULL;  
        if(front == NULL || rear == NULL){  
                front = rear = qe;  
        }else{  
                rear->next = qe;  
                qe->pre = rear;  
                rear = qe;  
        }  
}  

//从队列中取出一个元素  
int* getQueue(){  
        if(front == NULL || rear == NULL){  
                return NULL;  
        }else{  
                int* res = (int*)malloc(sizeof(int));  
                *res = front->value;  

                st_qElement* p = front;  
                front = front->next;  
                if(front == NULL){  
                        rear = front;  
                }else{  
                        front->pre = NULL;  
                }  
                free(p);  
                p = NULL;  
                return res;  
        }  
}
//将顶点关联的元素放到队列中  
void putRelatedInQueue(int (*edge)[VERTEXNUM], int vertex){  
        int i;  
        for(i=0;i<VERTEXNUM;i++){  
                if(edge[vertex][i] == 1){  
                        putQueue(i);  
                }  
        }  
}

结果图：
邻接矩阵BFS结果图

BFS邻接表

#include <stdio.h>  
#include <malloc.h>  
#define VERTEXNUM 5  

//存放顶点的邻接表元素  
typedef struct edge{  
        int vertex;  
        struct edge* next;  
}st_edge;  

//队列的元素  
typedef struct qElement{  
        int value;  
        struct qElement* pre;  
        struct qElement* next;  
}st_qElement;  

//队列的前端和后端，最后一个入队列的元素为rear，第一个出队列的元素为front  
st_qElement* front = NULL;  
st_qElement* rear = NULL;  

void createGraph(st_edge** edge, int start, int end);  
void displayGraph(st_edge** edge);  
void delGraph(st_edge** edge);  
void BFT(st_edge** edge,int* vertexStatusArr);  
void BFTcore(st_edge** edge,int i,int* vertexStatusArr);  
void putQueue(int vertex);  
int* getQueue();  
void putRelatedInQueue(st_edge** edge, int vertex);  

int main(void){  
        //动态创建存放边的指针数组   
        st_edge** edge = (st_edge**)malloc(sizeof(st_edge*)*VERTEXNUM);  
        int i;  
        for(i=0;i<VERTEXNUM;i++){  
                edge[i] = NULL;  
        }  

        //存放顶点的遍历状态，0：未遍历，1：已遍历  
        int* vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);  
        for(i=0;i<VERTEXNUM;i++){  
                vertexStatusArr[i] = 0;  
        }  

        printf("after init:\n");  
        displayGraph(edge);  
        //创建图  
        createGraph(edge,0,3);  
        createGraph(edge,0,4);  
        createGraph(edge,3,1);  
        createGraph(edge,3,2);  
        createGraph(edge,4,1);  

        printf("after create:\n");  
        displayGraph(edge);  

        //广度优先遍历  
        BFT(edge,vertexStatusArr);  

        //释放邻接表占用的内存  
        delGraph(edge);  
        edge = NULL;  
        free(vertexStatusArr);  
        vertexStatusArr = NULL;  
        return 0;  
}  

//创建图  
void createGraph(st_edge** edge, int start, int end){  
        st_edge* newedge = (st_edge*)malloc(sizeof(st_edge));  
        newedge->vertex = end;  
        newedge->next = NULL;  
        edge = edge + start;  
        while(*edge != NULL){  
                edge = &((*edge)->next);  
        }  
        *edge = newedge;  
}  

//打印存储的图  
void displayGraph(st_edge** edge){  
        int i;  
        st_edge* p;  
        for(i=0;i<VERTEXNUM;i++){  
                printf("%d:",i);  
                p = *(edge+i);  
                while(p != NULL){  
                        printf("%d ",p->vertex);  
                        p = p->next;  
                }  
                printf("\n");  
        }  
}  

//释放邻接表占用的内存  
void delGraph(st_edge** edge){  
        int i;  
        st_edge* p;  
        st_edge* del;  
        for(i=0;i<VERTEXNUM;i++){  
                p = *(edge+i);  
                while(p != NULL){  
                        del = p;  
                        p = p->next;  
                        free(del);  
                }  
                edge[i] = NULL;  
        }  
        free(edge);  
}  

//广度优先遍历  
void BFT(st_edge** edge,int* vertexStatusArr){  
        printf("start BFT graph:\n");  
        int i;  
        for(i=0;i<VERTEXNUM;i++){  
                BFTcore(edge,i,vertexStatusArr);  
        }  
        printf("\n");  
}  

void BFTcore(st_edge** edge,int i,int* vertexStatusArr){  
        putQueue(i);  
        int* qeValue = NULL;  
        while((qeValue = getQueue()) != NULL){  
                if(vertexStatusArr[*qeValue] == 0){  
                        printf("%d ",*qeValue);  
                        vertexStatusArr[*qeValue] = 1;  
                        putRelatedInQueue(edge, *qeValue);  
                }  
                free(qeValue);  
                qeValue = NULL;  
        }  
}  

//将元素放到队列中  
void putQueue(int vertex){  
        st_qElement* qe = (st_qElement*)malloc(sizeof(st_qElement));  
        qe->value = vertex;  
        qe->next = NULL;  
        qe->pre = NULL;  
        if(front == NULL || rear == NULL){  
                front = rear = qe;  
        }else{  
                rear->next = qe;  
                qe->pre = rear;  
                rear = qe;  
        }  
}  

//从队列中获取一个元素  
int* getQueue(){  
        if(front == NULL || rear == NULL){  
                return NULL;  
        }else{  
                int* res = (int*)malloc(sizeof(int));  
                *res = front->value;  

                st_qElement* p = front;  
                front = front->next;  
                if(front == NULL){  
                        rear = front;  
                }else{  
                        front->pre = NULL;  
                }  
                free(p);  
                p = NULL;  
                return res;  
        }  
}  

//将顶点关联的元素放到队列中  
void putRelatedInQueue(st_edge** edge, int vertex){  
        st_edge* p = *(edge+vertex);  
        while(p != NULL){  
                putQueue(p->vertex);  
                p = p->next;  
        }  
}

结果图
邻接表表示BFS结果图
转载自：
http://blog.youkuaiyun.com/TODD911/article/details/9182531

图的宽度优先遍历
Python、C++、HTML、Java
04-14 1467
【问题描述】根据输入图的邻接矩阵A，给出图的宽度优先遍历序列； 【输入形式】第一行为图的结点个数n，第二行输入顶点的信息，每个顶点用一个字符表示，接下来的n行为图的邻接矩阵A。其中A[i][j]=1表示两个结点邻接，而A[i][j]=0表示两个结点无邻接关系。 【输出形式】从第一顶点出发的图的宽度优先遍历序列 【样例输入】 8 abcdefgh 0 1 1 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1
探索图的遍历方式：深度优先遍历与宽度优先遍历
最新发布
Lostgreen的博客
02-10 849
重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。
邻接矩阵的两种遍历算法
lionway
05-18 1193
#include using namespace std;   const int maxsize=10; template class mgraph {     public:         mgraph(type a[],int n,int e);         ~mgraph(){}         void dfstravese(int v);
宽度优先遍历(Breadth-First Search, BFS)
努力学习的DS
06-14 1456
BFS，其英文全称是Breadth First Search。 BFS并不使用经验法则算法。从算法的观点，所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中。目的是系统地展开并检查图中的所有节点，以找寻结果。 ...
图的广度优先遍历BFS(邻接矩阵表示法)
xwdreamer的专栏
06-13 4211
1.前言复习算法第四章——图中的路径，首先完成算法广度优先遍历，其中使用到了队列结构2.参考资料http://blog.youkuaiyun.com/lengyuhong/archive/2010/01/06/5145100.aspx3.相关博客在之前的博客中完成了图的深度优先遍历，也是使用邻接矩阵表示法。图的深度优先遍历(邻接矩阵表示法) 4.代码实现#inc
图的邻接矩阵：广度优先遍历
JeredYe的博客
05-09 227
图的邻接矩阵：广度优先遍历
C++数据结构与算法分析——BFS(宽度优先遍历)
l_red_forest的博客
09-13 3037
BFS 介绍 BFS也叫宽度优先遍历，广度优先遍历，宽度优先搜索，广度优先搜索，是一种常用的搜索手段。
Leetcode练习：墙与门，python解法，宽度优先遍历 BFS
yzl14的博客
09-09 672
题目： 你被给定一个m × n的二维网格，网格中有以下三种可能的初始化值： -1表示墙或是障碍物 0表示一扇门 INF无限表示一个空的房间。然后，我们用231 - 1 = 2147483647代表INF。你可以认为通往门的距离总是于2147483647的。 你要给每个空房间位上填上该房间到最近门的距离，如果无法到达门，则填INF即可。 示例： 给定二维网格： ...
图的宽度优先遍历（BFS）java源码
JZ
10-05 3292
import java.util.HashSet; import java.util.LinkedList; import java.util.Queue; /** * * 图的宽度优先遍历 * */ public class Code_01_BFS { public static void bfs(Node node) { if (node == null) { ...
无向图-邻接矩阵-宽度优先遍历-BFS C代码实现
qiki_糖没味儿的程序媛小屋
02-21 5474
一、BFS算法思路本算法以无向图为例，存储方式采用邻接矩阵1）将该网以邻接矩阵的方式存储，由于这里的示例采用无向图，因此它是一个对称阵2）选取A点为起始点，访问此顶点，用一个visit的bool型数组记录访问状态（false表示未被访问，true表示已访问）3）从A的未被访问的邻接点出发，宽度优先遍历图，直到图中所有和v有路径相通的顶点都被访问到宽度优先遍历需要借助队列，思想与二叉树的层序遍历类似...
数据结构 邻接矩阵宽度优先搜索
小胡同的诗
04-10 423
实验十二、无向图的邻接矩阵存储及广度优先搜索遍历 1 实验目的 本实验实现无向图的邻接矩阵存储，并输出邻接矩阵, 以及该无向图的广度优先遍历序列。 2 实验内容 建立如图所示的无向图G的邻接矩阵，并输出该矩阵。 输出广度优先遍历序列 Code： #include<stdio.h> #include<stdlib.h> #include<windows.h&gt...
C++笔记-基于邻接矩阵的BFS（宽度优先遍历）
IT1995的博客
06-29 1289
邻接表是是用一个二维链表，表示顶点和顶点相邻的节点。 而邻接矩阵是，他的行，代表的是顶点，列也代表的顶点，如下： 第0行：这是第0个顶点，他可以去第1个和第2个顶点； 第1行：这是第1个顶点，他可以去第4个顶点； 第2行：这是第2个顶点，他可以去第0个和第2和第3个顶点； 第3行：这是第3个顶点，他可以去第0个和第4个顶点； 第4行，这是第4个顶点，他一个顶点也不能走。 思路BFS都一样，先选一个顶点，然后看他可以访问哪个顶点，然后依次访问： 运行截图：先访问0这个顶点，在1，2
《算法笔记》—— 图 "邻接矩阵" 的遍历（DFS、BFS）
浪子花梦
04-14 7265
此文知识点相关文章 与数据结构 —— 图相关的文章有： 初探数据结构 —— 图 (邻接矩阵实现) 初探数据结构 —— 图 (邻接表实现) 与DFS、BFS相关的文章有： 《算法笔记》—— “迷宫求解” 之 深度优先搜索（DFS） 《算法笔记》—— “迷宫求解” 之广度优先搜索（BFS） 文章目录 图 —— 邻接矩阵 DFS遍历原理 BFS遍历原理 DFS遍历邻接矩阵源码讲解 BF...
C++笔记-基于邻接表的BFS（宽度优先遍历）
bai_Mou的博客
08-31 346
这里是基于邻接表的，有向的，具体代码如下： #include <iostream> #include <list> using namespace std; class Graph { int V; list<int> *adj; public: Graph(int V); void addEdge(int v, int w); void BFS(int s); }; Graph::Graph(int V) { th
无向图-邻接链表-宽度优先遍历-BFS C代码实现
qiki_糖没味儿的程序媛小屋
02-21 730
一、算法思路本算法以无向图为例，存储方式采用邻接表1）将该网以邻接表的方式存储，由于这里的示例采用无向图，因此它是一个对称阵2）选取A点为起始点，访问此顶点，用一个visit的bool型数组记录访问状态（false表示未被访问，true表示已访问）3）从A的未被访问的邻接点出发，宽度优先遍历图，直到图中所有和v有路径相通的顶点都被访问到二、BFS测试用例        本算法的测试用例为《大话数据...
南邮数据结构实验3.4：以邻接表为存储结构的图的深度、宽度优先遍历
Wonz
06-30 5974
题目：以实验3.3所示邻接表为存储结构，编写程序，实现图的深度、宽度优先遍历。 部分代码： 邻接表的单一顶点DFS： //邻接表的单一顶点DFS void DFS(int v,int visited[],LGraph g){ ENode *w; printf("%d ",v); //访问顶点v visited[v]...
BFS广度优先搜索遍历
Depthslowly的博客
10-27 1829
广度优先搜索遍历 Problem Description 给定一个无向连通图，顶点编号从0到n-1，用广度优先搜索(BFS)遍历，输出从某个顶点出发的遍历序列。(同一个结点的同层邻接点，节点编号小的优先遍历） Input 输入第一行为整数n（0 对于每组数据，第一行是三个整数k，m，t（0＜k＜100，0＜m＜(k-1)*k/2，0＜ t＜k），表示有m条边，k个顶点，t
宽度优先遍历和深度优先遍历
01-06
### 宽度优先遍历与深度优先遍历的区别 #### 算法机制差异 宽度优先遍历（BFS）遵循逐层扩展的原则，从起始节点出发，依次访问其所有邻接节点，再按相同方式处理这些新发现的节点直到全部节点被访问完毕[^1]。相比之下，深度优先遍历（DFS）则采取深入探索的方式，在遇到未访问过的分支时会尽可能深地沿着该路径前进直至无法继续为止，随后回溯至上一可选位置并重复此过程。 对于具体实现而言： - **BFS**通常借助队列数据结构完成操作，每次都将当前层次的所有子节点加入到待处理列表末端； - **DFS**更多依赖栈或递归来管理状态转移序列，每当进入新的子树前都会保存现有环境以便后续返回时恢复现场[^3]。 ```python from collections import deque def bfs(graph, start): visited = set() queue = deque([start]) while queue: vertex = queue.popleft() if vertex not in visited: print(vertex) visited.add(vertex) for neighbor in graph[vertex]: if neighbor not in visited: queue.append(neighbor) def dfs(graph, start, visited=None): if visited is None: visited = set() stack = [start] while stack: vertex = stack.pop() if vertex not in visited: print(vertex) visited.add(vertex) stack.extend( neighbor for neighbor in reversed(graph[vertex]) if neighbor not in visited ) ``` #### 应用场景对比 当面对连通性检测、最短路径查找等问题时，由于BFS能够保证首次到达目标节点所经过的距离是最优解之一，故而更适合此类需求；而在涉及拓扑排序、强连通分量识别以及某些特定模式匹配的情况下，则往往更倾向于采用能快速触及深层结构特性的DFS方法[^2]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值