广度优先搜索（BFS）

置顶 已于 2023-08-04 15:22:13 修改
阅读量5.5k 收藏 20
点赞数 1
分类专栏： 数据结构与算法 文章标签： bfs 广度优先 数据结构 算法
于 2023-08-03 22:37:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68805093/article/details/132070826
版权

目录

一、广度优先搜索（BFS）原理

二、广度优先搜索应用场景

三、C++实现广度优先搜索

1. 邻接表图的定义

2. 图初始化

3. 插入边

4. 在main函数中创建一个图

5. 访问顶点的函数

6. 求得顶点v的第一条边的指针

7. BFS算法

8. 对图graph进行广度优先遍历

四、完整示例代码

五、运行结果

一、广度优先搜索（BFS）原理

        广度优先搜索是一种图搜索算法，它通过逐层遍历图的节点来查找目标节点。该算法从起始节点开始，先访问起始节点，然后访问起始节点的所有邻居节点，接着再访问这些邻居节点的邻居节点，以此类推，直到遍历完所有可达节点。为了实现逐层遍历，我们通常使用队列来保存待访问的节点。

        图的广度优先搜索的过程与二叉树的层序遍历是完全一致的，BFS其实就是二叉树的层序遍历算法的推广。 

二、广度优先搜索应用场景

广度优先搜索在很多领域都有广泛的应用，包括但不限于：

  1. 图的遍历：用于遍历图中的所有节点，查找特定节点或找到从起始节点到目标节点的最短路径。
  2. 迷宫问题：用于找到从起点到终点的最短路径，或者找到是否有路径可以从起点到达终点。
  3. 社交网络分析：用于查找两个用户之间的最短路径或共同的联系人。
  4. 网络路由：用于寻找最优路由和解决网络拓扑问题。

三、C++实现广度优先搜索

以下是用 C++实现广度优先搜索的简单示例代码，假设我们使用邻接表来表示图：

1. 邻接表图的定义
#define MAX_VERTICES 100
typedef int VertexType;

// 定义图的边结构
typedef struct Edge {
    int adjVertex;      // 与边相连的另一顶点的索引
    Edge* next;         // 指向下一条邻接边的指针
} Edge;

// 定义图的顶点结构
typedef struct Vertex {
    VertexType data;    // 顶点数据
    Edge* firstEdge;    // 指向第一个邻接边的指针
} Vertex;

// 定义图的邻接表结构
typedef struct Graph {
    int num_vertices, num_edges;     // 图中顶点的数量
    Vertex vertices[MAX_VERTICES];  // 存储顶点的数组
} Graph;
2. 图初始化
// 初始化图
void initGraph(Graph* graph, int num_vertices) {
    graph->num_vertices = num_vertices;
    graph->num_edges = 0;
    for (int i = 0; i < num_vertices; ++i) {
        graph->vertices[i].data = i+97;      // 顶点数据字母a开始
        graph->vertices[i].firstEdge = NULL; // 初始化顶点的邻接边链表为空
    }
}
3. 插入边
// 向图中插入一条边    (无向图）
void insertEdge(Graph* graph, int from, int to) {
    if (from >= 0 && from < graph->num_vertices && to >= 0 && to < graph->num_vertices) {
        // 创建新的边节点，插到from的这条链的链头
        Edge* newEdge = (Edge*)malloc(sizeof(Edge));
        newEdge->adjVertex = to;
        newEdge->next = graph->vertices[from].firstEdge;
        // 更新顶点的邻接边链表
        graph->vertices[from].firstEdge = newEdge;

        // 创建新的边节点，插到to的这条链的链头
        Edge* NewEdge = (Edge*)malloc(sizeof(Edge));
        NewEdge->adjVertex = from;
        NewEdge->next = graph->vertices[to].firstEdge;
        // 更新顶点的邻接边链表
        graph->vertices[to].firstEdge = NewEdge;

        graph->num_edges++;
    }
}
4. 在main函数中创建一个图
Graph graph;
initGraph(&graph, 8);   //初始化8个顶点
insertEdge(&graph, 0, 2);   //a-c
insertEdge(&graph, 0, 1);   //a-b
insertEdge(&graph, 1, 4);   //b-e
insertEdge(&graph, 1, 3);   //b-d
insertEdge(&graph, 2, 6);   //c-g
insertEdge(&graph, 2, 5);   //c-f
insertEdge(&graph, 4, 7);   //e-h

 建好的图如下： 

广度优先遍历的结果应该是abcdefgh 

5. 访问顶点的函数
void visit(Graph graph, int v) { //访问顶点，这里是打印
    cout << (char)graph.vertices[v].data;
}
6. 求得顶点v的第一条边的指针
//FirstNeighbor(graph, v)是求得与v关联的第一个顶点的指针，没有就return NULL
Edge* FirstNeighbor(Graph graph, int v) {
    if (graph.vertices[v].firstEdge != NULL) { //与顶点v关联的第一条边存在
        return graph.vertices[v].firstEdge;
    }
    return NULL;
}
7. BFS算法
bool visited[MAX_VERTICES];         //用于标记顶点是否被访问过，访问过为true
queue<int> q;                       //C++STL中的队列，创建一个辅助队列

//BFS算法
void BFS(Graph graph, int v) {      //v是顶点的下标
    visit(graph,v);                 //对顶点v的操作，可以是打印等等
    visited[v] = true;              //标记已访问过
    q.push(v);                      //顶点v入队
    while (!q.empty()) {            //当队列不为空时
        int QueueHead=q.front();    //获取当前处于队头的顶点
        q.pop();                    //获取队头后然后再出队
        Edge* p = FirstNeighbor(graph, QueueHead);  //得到上面获取的队头的指向第一条边的指针
        //这层循环将访问与QueueHead关联的所有顶点
        while ( p != NULL) {        //p不为空说明QueueHead有关联的边
            int w = p->adjVertex;   //w是与v关联的顶点下标
            if (!visited[w]) {      //未访问
                visit(graph,w);     //访问顶点
                visited[w] = true;  //标记为已访问
                //入队，每次都是先访问标记后再入队
                //所以队列中的元素一定是被访问过的
                q.push(w);  
            }
            p = p->next;
        }
    }
}
8. 对图graph进行广度优先遍历
void BFS_Traverse(Graph graph) {   //对图graph进行广度优先遍历
    for (int i = 0; i < graph.num_vertices; i++) {  //初始化标记数组
        visited[i] = false;
    }
    BFS(graph,0);
    //若有多个连通分量，则继续调用BFS(graph,v);v是每个连通分量的任意一个顶点
}

四、完整示例代码

#include<iostream>
#include<queue>
using namespace std;
#define MAX_VERTICES 100
typedef int VertexType;

// 定义图的边结构
typedef struct Edge {
    int adjVertex;      // 与边相连的另一顶点的索引
    Edge* next;         // 指向下一条邻接边的指针
} Edge;

// 定义图的顶点结构
typedef struct Vertex {
    VertexType data;    // 顶点数据
    Edge* firstEdge;    // 指向第一个邻接边的指针
} Vertex;

// 定义图的邻接表结构
typedef struct Graph {
    int num_vertices, num_edges;     // 图中顶点的数量
    Vertex vertices[MAX_VERTICES];  // 存储顶点的数组
} Graph;

// 初始化图
void initGraph(Graph* graph, int num_vertices) {
    graph->num_vertices = num_vertices;
    graph->num_edges = 0;
    for (int i = 0; i < num_vertices; ++i) {
        graph->vertices[i].data = i+97;      // 顶点数据字母a开始
        graph->vertices[i].firstEdge = NULL; // 初始化顶点的邻接边链表为空
    }
}

// 向图中插入一条边    (无向图）
void insertEdge(Graph* graph, int from, int to) {
    if (from >= 0 && from < graph->num_vertices && to >= 0 && to < graph->num_vertices) {
        // 创建新的边节点，插到from的这条链的链头
        Edge* newEdge = (Edge*)malloc(sizeof(Edge));
        newEdge->adjVertex = to;
        newEdge->next = graph->vertices[from].firstEdge;
        // 更新顶点的邻接边链表
        graph->vertices[from].firstEdge = newEdge;

        // 创建新的边节点，插到to的这条链的链头
        Edge* NewEdge = (Edge*)malloc(sizeof(Edge));
        NewEdge->adjVertex = from;
        NewEdge->next = graph->vertices[to].firstEdge;
        // 更新顶点的邻接边链表
        graph->vertices[to].firstEdge = NewEdge;

        graph->num_edges++;
    }
}

void visit(Graph graph, int v) { //访问顶点，这里是打印
    cout << (char)graph.vertices[v].data;
}

//FirstNeighbor(graph, v)是求得与v关联的第一个顶点的指针，没有就return NULL
Edge* FirstNeighbor(Graph graph, int v) {
    if (graph.vertices[v].firstEdge != NULL) { //与顶点v关联的第一条边存在
        return graph.vertices[v].firstEdge;
    }
    return NULL;
}

bool visited[MAX_VERTICES];         //用于标记顶点是否被访问过，访问过为true
queue<int> q;                       //C++STL中的队列，创建一个辅助队列

//BFS算法
void BFS(Graph graph, int v) {      //v是顶点的下标
    visit(graph,v);                 //对顶点v的操作，可以是打印等等
    visited[v] = true;              //标记已访问过
    q.push(v);                      //顶点v入队
    while (!q.empty()) {            //当队列不为空时
        int QueueHead=q.front();    //获取当前处于队头的顶点
        q.pop();                    //获取队头后然后再出队
        Edge* p = FirstNeighbor(graph, QueueHead);  //得到上面获取的队头的指向第一条边的指针
        //这层循环将访问与QueueHead关联的所有顶点
        while ( p != NULL) {        //p不为空说明QueueHead有关联的边
            int w = p->adjVertex;   //w是与v关联的顶点下标
            if (!visited[w]) {      //未访问
                visit(graph,w);     //访问顶点
                visited[w] = true;  //标记为已访问
                //入队，每次都是先访问标记后再入队
                //所以队列中的元素一定是被访问过的
                q.push(w);  
            }
            p = p->next;
        }
    }
}

void BFS_Traverse(Graph graph) {   //对图graph进行广度优先遍历
    for (int i = 0; i < graph.num_vertices; i++) {  //初始化标记数组
        visited[i] = false;
    }
    BFS(graph,0);
    //若有多个连通分量，则继续调用BFS(graph,v);v是每个连通分量的任意一个顶点
}

int main() {
    Graph graph;
    initGraph(&graph, 8);   //初始化8个顶点
    insertEdge(&graph, 0, 2);   //a-c
    insertEdge(&graph, 0, 1);   //a-b
    insertEdge(&graph, 1, 4);   //b-e
    insertEdge(&graph, 1, 3);   //b-d
    insertEdge(&graph, 2, 6);   //c-g
    insertEdge(&graph, 2, 5);   //c-f
    insertEdge(&graph, 4, 7);   //e-h

    BFS_Traverse(graph);
	return 0;
}

五、运行结果

        结果完全正确！！！ 

不想学习啊啊
关注
  • 1
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
人工智能 广度优先搜索BFS和A*搜索策略 C语言实现代码+实验报告
01-04
人工智能 广度优先搜索和A*搜索策略 C语言实现代码+实验报告 1)开发环境：C++ 2)功能要求：分别使用广度优先搜索和A*搜索策略 应用于8-puzzle的解答上 3)问题描述： 1.在图1，3*3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空。(0表示空)  2.如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态（图1左）到目标状态（图1右）。 3.可自行设计初始状态。目标状态为数字从小到大按顺时针排列。 4.分别用广度优先搜索策略、和启发式搜索算法（A*算法）求解八数码问题； 1>BFS 1)状态表示的数据结构 //状态 struct State { int arr[3][3]; //记录九宫格 int zeroX; //0所在的横坐标 int zeroY; //0所在的纵坐标 int f; //父节点的位置，根节点的父节点记为-1 int d; //与根节点的距离 }states[maxNum]; 2)状态扩展规则的表示 ①　对当前结点进行拓展，0点朝上下左右四个位置移动改变状态，若当前移动会超出边界则放弃朝该方向移动。 ②　判断移动后的状态是否与之前已经拓展过或存储的结点状态重复，若重复则删除，反之把状态存入表中。 ③　检查新状态是否与目标状态相同，若是则输出移动路径，搜索结束。反之指针指向open表中的下一个结点，重复①②③，直到当前节点为空，寻找结束，未搜索到路径。 3)搜索产生的状态空间图(以棋盘初始状态为283104765为例) 2>A*搜索算法 1)状态表示的数据结构 // 八数码 typedef struct node { int arr[N][N]; //数组记录 int zeroX, zeroY; //0的位置 int d, w, f; //搜索深度，曼哈顿距离代价，总代价 struct node *father;//指向父节点的指针 }node, *pNode; // 顺序表 typedef struct list { pNode arr[maxSize]; long len; }list, *pList; 2)状态扩展规则的表示 ①　对当前结点进行拓展，0点朝上下左右四个位置移动改变状态，若当前移动会超出边界则放弃朝该方向移动。 ②　判断移动后的状态是否与之前已经拓展过或存储的结点状态重复，若重复则删除，反之把状态存入表中。 ③　检查新状态是否与目标状态相同，若是则输出移动路径，搜索结束。反之将open表中的结点按照f生序排序，指针指向open表中的下一个结点，重复①②③，直到当前节点为空，寻找结束，未搜索到路径。 3)搜索产生的状态空间图 以棋盘初始状态为283164705为例 4. 调试分析 对程序的调试通过DevC++内置的调试工具和printf语句完成
【Python搜索算法】广度优先搜索（BFS）算法原理详解与应用，示例+代码
qq_35831906的博客
10-16 4938
广度优先搜索（Breadth-First Search，BFS）是一种图遍历算法，用于系统地遍历或搜索图（或树）中的所有节点。BFS的核心思想是从起始节点开始，首先访问其所有相邻节点，然后逐层向外扩展，逐一访问相邻节点的相邻节点，以此类推。这意味着BFS会优先探索距离起始节点最近的节点，然后再逐渐扩展到距离更远的节点。BFS通常用于查找最短路径、解决迷宫问题、检测图是否连通以及广泛的图问题。BFS算法的步骤如下：初始化：选择一个起始节点，将其标记为已访问，并将其放入队列中（作为起始节点）。
广度优先搜索和深度优先搜索
liulanba的博客
03-09 973
以邻接矩阵表示时，查找每个顶点的邻接点所需的时间为0(V)，故总的时间复杂度为0（V²).以邻接表表示时，查找所有顶点的邻接点所需的时间为O(E)，访问顶点所需的时间为0（V)），此时，总的时间复杂度为O(V+|E|)。采用邻接表存储方式时，每个顶点均需搜索一次（或入队一次)，故时间复杂度为0(V)，在搜索任一顶点的邻接点时，每条边至少访问一次，故时间复杂度为 0(E)，算法总的时间复杂度为0(V+E)。注意：图的邻接矩阵表示是唯一的，但对于邻接表来说，若边的输入次序不同，生成的邻接表也不同。
BFS 广度优先搜索算法 matlab
03-19
本程序实现了对一颗树的广度优先搜索，通过本程序还可以判断图的连通性 本程序实现了对一颗树的广度优先搜索，通过本程序还可以判断图的连通性
数据结构与算法(四) 广度优先搜索
半虹小站
11-15 2869
本篇文章继续来学习广度优先搜索算法（Broad-First-Search，BFS）
广度优先搜索算法（BFS）详解
热门推荐
lemonxiaoxiao的博客
04-24 3万+
参考：https://www.cnblogs.com/tianqizhi/p/9914539.html 广度优先搜索算法（又称宽度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS（breadth-first search），属于一种盲目搜寻法，目的是系统地展开...
广度优先搜索（BFS）详解
m0_69596371的博客
06-12 4746
广度优先搜索（BFS）是一种用于图形数据结构的遍历算法，它从给定的起始顶点开始，以广度优先的方式逐层搜索图中的节点，直到找到目标节点或遍历完整个图。BFS算法通常使用队列数据结构来实现，它的时间复杂度为O(V+E)，其中V表示图中顶点数，E表示边数。BFS算法在求解最短路径、连通性、拓扑排序等问题中具有重要应用。广度优先搜索（Breadth First Search）,简称广搜（BFS）。广搜是逐层扩展状态的搜索策略，常用于解决连通性问题和最短路问题。
算法数据结构——图的遍历之广度优先搜索算法（Breadth First Search）
白话机器学习
06-06 7972
广度优先搜索算法（Breadth First Search）：简称为 BFS，又译作宽度优先搜索 / 横向优先搜索。是一种用于遍历或搜索树或图的算法。该算法从根节点开始，沿着树的宽度遍历树或图的节点。如果所有节点均被访问，则算法中止。广度优先遍历类似于树的层次遍历过程。呈现出一层一层向外扩张的特点。先看到的节点先访问，后看到的节点后访问。遍历到的节点顺序符合「先进先出」的特点，所以广度优先搜索可以通过「队列」来实现。
广度优先搜索
Mark1277的博客
05-26 2857
注：最近有些事所以请大家原谅那么废话讲完了┏ (゜ω゜)=☞。
广度优先搜索（BFS）（算法笔记）
Arabot_的博客
03-23 1840
深度优先搜索是一种枚举所有完整路径以遍历所有情况的搜索方法，总是以“广度”作为前进的关键词，采用队列实现。广度优先搜索属于搜索问题的一种，当问题可以被描述为“路径搜索”时，就可以采用搜素问题的所有解的方式来进行解决，所以BFS本质还是暴力。广搜也存在“岔道口”，只是当遇到“岔道口”时，需要将本层所有的岔道都走一遍，然后再走下一层的岔道，符合队列的“先进先出”思想。广搜和深搜的共同点之一是只有一个起点，也就是说一次搜索只能遍历以一个点为起点的所有路径。而BFS更适合需要搜索最优解的问题，
小孩分油问题(广度优先搜索算法)实验报告及c++程序
11-25
小孩分油问题(广度优先搜索算法)实验报告，附带c++代码，详细流程及流程图
宽度优先搜索 算法.doc
06-09
采用宽度优先搜索算法，编程实现八数码问题的求解。初始状态和目标状态可自定；采用宽度优先搜索算法，编程实现八数码问题的求解。初始状态和目标状态可自定采用宽度优先搜索算法，编程实现八数码问题的求解。初始状态和目标状态可自定采用宽度优先搜索算法，编程实现八数码问题的求解。初始状态和目标状态可自定采用宽度优先搜索算法，编程实现八数码问题的求解。初始状态和目标状态可自定
06D 广度优先搜索 BFS1
08-03
06D 广度优先搜索 BFS1
基于Python的图搜索算法实现：广度优先搜索BFS，Dijkstra 算法，贪心最佳优先搜索，A*搜索
最新发布
04-19
改代码实现了广度优先搜索BFS，Dijkstra 算法，贪心最佳优先搜索，A*搜索，并提供了将搜索结果画图展示的接口。 在入口文件处，提供了如何调用各类算法的例子以及演示了使用画图接口的方法。
MATLAB源码集锦-基于BFS广度优先搜索算法代码
02-14
MATLAB源码集锦-基于BFS广度优先搜索算法代码
广度优先搜索BFS-VC6.0全工程
08-07
使用MFC写的简单广度优先搜索迷宫算法，可以自己选择起点终点。在探索到终点时会显示一条搜索路径。代码简单，仅供学习交流使用
06_第六章 广度优先搜索（bfs）
12-20
学习广度优先搜索（breadth-first search BFS），你可对图使用这种算法诸如 “ 到x的最短距离是什么 ” 等问题 学习有向图和无向图 学习拓扑排序，这种排序算法指出了节点之间的依赖  首先，这个图，不涉及x...
请分析深度优先搜索DFS和广度优先搜索BFS的优缺点。
05-28
深度优先搜索（DFS）和广度优先搜索（BFS）都是常见的图遍历算法，它们各自有优缺点，适用于不同的场景。 DFS 的优点： 1. 实现简单，只需要一个栈来保存遍历路径 2. 对于深度比较小的图，DFS 搜索速度较快 3. 在搜索到目标节点时，DFS 可能会比 BFS 更快找到一条较短的路径 DFS 的缺点： 1. 对于深度较大的图，DFS 可能会出现堆栈溢出的问题 2. DFS 可能陷入局部最优解而无法找到最优解 3. DFS 可能会搜索到无限制的路径上，导致无法结束搜索 BFS 的优点： 1. 对于求最短路径问题，BFS 可以保证第一次搜索到目标节点时，所经过的路径就是最短路径 2. 对于搜索较为稠密的图，BFS 的效率比 DFS 高 3. BFS 可以搜索到所有的路径，而不仅仅是一条路径 BFS 的缺点： 1. 实现比 DFS 复杂，需要使用队列来保存遍历路径 2. 对于深度较大的图，BFS 的空间复杂度较高，需要保存大量节点信息 3. 在搜索到目标节点时，BFS 可能不如 DFS 快速找到一条较短的路径 因此，选择 DFS 还是 BFS，要根据实际问题的特点来决定。如果需要搜索最短路径，或者图较为稠密，可以选择 BFS。如果图深度较小，或者只需要找到一条路径，可以选择 DFS。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

不想学习啊啊

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

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

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

打赏作者

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

抵扣说明：

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

余额充值