宽度优先遍历（BFS）

最新推荐文章于 2024-09-10 19:40:29 发布
最新推荐文章于 2024-09-10 19:40:29 发布
阅读量1k 收藏 1
点赞数
分类专栏： 算法 文章标签： bfs 遍历 C语言 广度优先遍历

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.csdn.net/TODD911/article/details/9182531

视学算法
关注
专栏目录
图的宽度优先遍历
兔子王
04-14 1375
【问题描述】根据输入图的邻接矩阵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
Leetcode练习：墙与门，python解法，宽度优先遍历 BFS
yzl14的博客
09-09 628
题目： 你被给定一个m × n的二维网格，网格中有以下三种可能的初始化值： -1表示墙或是障碍物 0表示一扇门 INF无限表示一个空的房间。然后，我们用231 - 1 = 2147483647代表INF。你可以认为通往门的距离总是于2147483647的。 你要给每个空房间位上填上该房间到最近门的距离，如果无法到达门，则填INF即可。 示例： 给定二维网格： ...
邻接矩阵的两种遍历算法
lionway
05-18 1162
#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 1395
BFS，其英文全称是Breadth First Search。 BFS并不使用经验法则算法。从算法的观点，所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中。目的是系统地展开并检查图中的所有节点，以找寻结果。 ...
算法【宽度优先遍历及其扩展】
最新发布
W_O_Z的博客
09-10 948
宽度优先遍历基本内容1.bfs的特点是逐层扩散，从源头点到目标点扩散了几层，最短路就是多少。2.bfs可以使用的特征是任意两个节点之间的相互距离相同（无向图）。3.bfs开始时，可以是单个源头、也可以是多个源头。4.bfs频繁使用队列，形式可以是单点弹出或者整层弹出。5.bfs进行时，进入队列的节点需要标记状态，防止同一个节点重复进出队列。6.bfs进行时，可能会包含剪枝策略的设计。7.bfs是一个理解难度很低的算法，难点在于节点如何找到路、路的展开和剪枝设计。
图的广度优先遍历BFS(邻接矩阵表示法)
xwdreamer的专栏
06-13 4167
1.前言复习算法第四章——图中的路径，首先完成算法广度优先遍历，其中使用到了队列结构2.参考资料http://blog.csdn.net/lengyuhong/archive/2010/01/06/5145100.aspx3.相关博客在之前的博客中完成了图的深度优先遍历，也是使用邻接矩阵表示法。图的深度优先遍历(邻接矩阵表示法) 4.代码实现#inc
图的邻接矩阵：广度优先遍历
JeredYe的博客
05-09 181
图的邻接矩阵：广度优先遍历
C++数据结构与算法分析——BFS(宽度优先遍历)
l_red_forest的博客
09-13 2818
BFS 介绍 BFS也叫宽度优先遍历，广度优先遍历，宽度优先搜索，广度优先搜索，是一种常用的搜索手段。
树以及树的遍历：宽度优先搜索BFS c++的代码实现
LovelyCat_mm的博客
05-04 1268
【输出格式】 输出一行，包括若干个大写字母，描述小球到达空洞的完整移动步骤，其中'U'代表向上走，'D'代表向下走，'L'代表向左走，'R'代表向右走。针对刚刚的图是有的，我们好好观察一下就会发现按照BFS的访问顺序就是1，2，3，4，5，6。他的原理是，先将父节点入队，判断是否符合要求，如果符合就可以退出循环了，如果不符，就继续将父节点的两个儿子入队，直到找到符合要求的结果为止。第2到n+1行 ，每行m个字母，描述棋盘的具体信息，其中'.'代表空格⼦，'#'代表障碍，'O'代表空洞，'B'代表球。
《算法竞赛入门经典》6-7 Trees on the level UVA122——二叉树的层次遍历（宽度优先遍历BFS）
qq_33672321的博客
04-06 309
Trees on the level UVA - 122 Trees are fundamental in many branches of computer science (Pun definitely intended). Current state- of-the art parallel computers such as Thinking Machines’ CM-5 ...
图的宽度优先遍历（BFS）java源码
JZ
10-05 3261
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 5259
一、BFS算法思路本算法以无向图为例，存储方式采用邻接矩阵1）将该网以邻接矩阵的方式存储，由于这里的示例采用无向图，因此它是一个对称阵2）选取A点为起始点，访问此顶点，用一个visit的bool型数组记录访问状态（false表示未被访问，true表示已访问）3）从A的未被访问的邻接点出发，宽度优先遍历图，直到图中所有和v有路径相通的顶点都被访问到宽度优先遍历需要借助队列，思想与二叉树的层序遍历类似...
数据结构 邻接矩阵宽度优先搜索
小胡同的诗
04-10 384
实验十二、无向图的邻接矩阵存储及广度优先搜索遍历 1 实验目的 本实验实现无向图的邻接矩阵存储，并输出邻接矩阵, 以及该无向图的广度优先遍历序列。 2 实验内容 建立如图所示的无向图G的邻接矩阵，并输出该矩阵。 输出广度优先遍历序列 Code： #include<stdio.h> #include<stdlib.h> #include<windows.h&gt...
C++笔记-基于邻接矩阵的BFS（宽度优先遍历）
IT1995的博客
06-29 1197
邻接表是是用一个二维链表，表示顶点和顶点相邻的节点。 而邻接矩阵是，他的行，代表的是顶点，列也代表的顶点，如下： 第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 6566
此文知识点相关文章 与数据结构 —— 图相关的文章有： 初探数据结构 —— 图 (邻接矩阵实现) 初探数据结构 —— 图 (邻接表实现) 与DFS、BFS相关的文章有： 《算法笔记》—— “迷宫求解” 之 深度优先搜索（DFS） 《算法笔记》—— “迷宫求解” 之广度优先搜索（BFS） 文章目录 图 —— 邻接矩阵 DFS遍历原理 BFS遍历原理 DFS遍历邻接矩阵源码讲解 BF...
C++笔记-基于邻接表的BFS（宽度优先遍历）
bai_Mou的博客
08-31 302
这里是基于邻接表的，有向的，具体代码如下： #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 671
一、算法思路本算法以无向图为例，存储方式采用邻接表1）将该网以邻接表的方式存储，由于这里的示例采用无向图，因此它是一个对称阵2）选取A点为起始点，访问此顶点，用一个visit的bool型数组记录访问状态（false表示未被访问，true表示已访问）3）从A的未被访问的邻接点出发，宽度优先遍历图，直到图中所有和v有路径相通的顶点都被访问到二、BFS测试用例        本算法的测试用例为《大话数据...
图的深度优先遍历和宽度优先遍历
11-27
宽度优先遍历（BFS）： 宽度优先遍历是一种用于遍历或搜索树或图的算法。在这种搜索方法中，从根结点开始，逐层遍历每个结点的所有子结点，直到到达最深的结点。宽度优先遍历使用队列来实现。 以下是宽度优先遍历的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值