数据结构与算法之广度优先算法

于 2023-09-17 11:24:47 发布
阅读量352 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 宽度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47225948/article/details/132940382
版权

数据结构与算法之广度优先算法

广度优先搜索（Breadth First Search，BFS）是一种图形搜索算法，用于遍历或搜索树或图的数据结构。其主要思想是从起点开始，依次遍历距离该节点最近的所有节点，再依次遍历距离该节点次近的所有节点，以此类推，直到找到目标节点或遍历完整个图。

具体实现上，BFS通常使用队列（Queue）数据结构存储待遍历的节点。从起点开始，将其加入队列中。之后，不断从队列中取出队首节点，并依次遍历其所有未被遍历的邻居节点。将这些邻居节点加入队列中，直到遍历到目标节点或队列为空为止。

BFS算法的优点是可以找到最短路径，即从起点到目标节点的最少步数。同时，BFS算法还可以用于解决一些应用问题，例如迷宫问题、社交网络分析等。

在这里插入图片描述


一、C语言之数据结构与算法之广度优先算法源码实现及详解

下面是一个示例C语言代码实现BFS算法：

#include <stdio.h>
#include <stdbool.h>

#define MAX_VERTICES 100  // 最大节点数量

typedef struct {
    int data[MAX_VERTICES];  // 节点数据
    int size;                // 节点数量
} Queue;

typedef struct {
    int vertices[MAX_VERTICES][MAX_VERTICES];  // 图的邻接矩阵
    int n;                                     // 节点数量
} Graph;

// 初始化队列
void initQueue(Queue *q) {
    q->size = 0;
}

// 判断队列是否为空
bool isQueueEmpty(Queue *q) {
    return q->size == 0;
}

// 入队
void enqueue(Queue *q, int data) {
    q->data[q->size++] = data;
}

// 出队
int dequeue(Queue *q) {
    int data = q->data[0];
    q->size--;
    for (int i = 0; i < q->size; i++) {
        q->data[i] = q->data[i + 1];
    }
    return data;
}

// BFS算法
void bfs(int start, Graph *g, bool visited[]) {
    Queue q;
    initQueue(&q);

    visited[start] = true;
    enqueue(&q, start);

    while (!isQueueEmpty(&q)) {
        int currentVertex = dequeue(&q);
        printf("%d ", currentVertex);

        for (int i = 0; i < g->n; i++) {
            if (g->vertices[currentVertex][i] == 1 && !visited[i]) {
                visited[i] = true;
                enqueue(&q, i);
            }
        }
    }
}

int main() {
    Graph g;
    g.n = 6;

    // 初始化邻接矩阵
    for (int i = 0; i < g.n; i++) {
        for (int j = 0; j < g.n; j++) {
            g.vertices[i][j] = 0;
        }
    }

    // 添加边
    g.vertices[0][1] = 1;
    g.vertices[0][2] = 1;
    g.vertices[1][2] = 1;
    g.vertices[2][0] = 1;
    g.vertices[2][3] = 1;
    g.vertices[3][3] = 1;
    g.vertices[4][5] = 1;
    g.vertices[5][4] = 1;

    bool visited[MAX_VERTICES] = { false };

    bfs(2, &g, visited);

    return 0;
}

在此示例代码中：

  • 使用邻接矩阵来表示图，表示节点之间的关系。
  • 使用队列来存储待遍历的节点，需要实现队列的入队和出队操作。
  • 使用 visited 数组来表示每个节点是否已经被遍历，防止重复遍历。

在main()函数中，建立一个简单的图，并使用广度优先搜索算法从节点2开始遍历整个图。

在这里插入图片描述


二、C++语言之数据结构与算法之广度优先算法源码实现及详解

下面是一个示例C++代码实现BFS算法：

#include <iostream>
#include <queue>
#include <vector>
#include <cstring>

using namespace std;

const int MAX_VERTICES = 100; // 最大节点数量

typedef vector<int> vi;
typedef vector<vi> vv;

bool visited[MAX_VERTICES]; // 表示每个节点是否已经被遍历，防止重复遍历

// BFS算法
void bfs(int start, const vv &graph) {
    queue<int> q;

    visited[start] = true;
    q.push(start);

    while (!q.empty()) {
        int currentVertex = q.front();
        q.pop();
        cout << currentVertex << " ";

        for (int i = 0; i < graph[currentVertex].size(); i++) {
            int neighbor = graph[currentVertex][i];
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                q.push(neighbor);
            }
        }
    }
}

int main() {
    vv graph(6); // 建立一个节点数量为6的图

    // 添加边
    graph[0].push_back(1);
    graph[0].push_back(2);
    graph[1].push_back(2);
    graph[2].push_back(0);
    graph[2].push_back(3);
    graph[3].push_back(3);
    graph[4].push_back(5);
    graph[5].push_back(4);

    memset(visited, false, sizeof(visited)); // 初始化visited数组

    bfs(2, graph); // 从节点2开始BFS遍历图

    return 0;
}

在此示例代码中：

  • 使用邻接表来表示图，表示节点之间的关系。
  • 使用队列来存储待遍历的节点，使用STL库中的queue实现，无需手动实现队列的操作。
  • 使用 visited 数组来表示每个节点是否已经被遍历，防止重复遍历。

在main()函数中，建立一个简单的图，并使用广度优先搜索算法从节点2开始遍历整个图。

在这里插入图片描述


三、java语言之数据结构与算法之广度优先算法源码实现及详解

广度优先算法（Breadth First Search，BFS）是一种常用的图形搜索算法，它从图形的起始节点开始，一层层地向外扩展搜索，直到找到目标节点或者整张图的节点都遍历完毕。BFS算法具有以下特点：

  1. 广度优先搜索是一种盲目搜索策略，不考虑各个节点之间的距离和权重，只关注节点之间的连通性。

  2. BFS算法可以用于寻找最短路径，因为它先搜索到的一定是距离起点最近的节点。

  3. BFS算法需要使用队列这种数据结构进行实现。

下面就来介绍一下BFS算法的源码实现及详解：

import java.util.ArrayDeque;
import java.util.Queue;

public class BFS {
    /* 定义节点类 */
    static class Node{
        int x, y;  // 节点的坐标
        Node(int x, int y){
            this.x = x;
            this.y = y;
        }
    }

    public static void main(String[] args) {
        /* 定义迷宫地图 */
        char[][] maze = {
                {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#'},
                {'#', '.', '#', '.', '.', '.', '#', '.', '.', '#'},
                {'#', '.', '#', '#', '.', '.', '#', '.', '#', '#'},
                {'#', '.', '.', '.', '.', '.', '.', '.', '.', '#'},
                {'#', '#', '#', '#', '#', '.', '#', '#', '.', '#'},
                {'#', '.', '.', '.', '.', '.', '#', '#', '#', '#'},
                {'#', '#', '#', '#', '.', '.', '.', '.', '.', '#'},
                {'#', '.', '.', '#', '.', '#', '.', '#', '.', '#'},
                {'#', '.', '.', '.', '#', '.', '#', '.', '.', '#'},
                {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#'},
        };

        /* 定义起点和终点 */
        Node start = new Node(1, 1);
        Node end = new Node(8, 8);

        /* 定义队列 */
        Queue<Node> queue = new ArrayDeque<>();
        queue.add(start);

        /* 定义数组记录每个节点是否被访问过 */
        boolean[][] visited = new boolean[10][10];
        visited[start.x][start.y] = true;

        /* 定义数组记录每个节点的父节点 */
        Node[][] parent = new Node[10][10];
        parent[start.x][start.y] = start;

        /* 开始广度优先搜索 */
        while(!queue.isEmpty()){
            /* 取出队列的头节点 */
            Node cur = queue.poll();
            /* 判断是否到达终点 */
            if(cur.x == end.x && cur.y == end.y) break;

            /* 遍历当前节点的所有邻居节点 */
            int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 定义四个方向
            for(int[] dir : dirs){
                int nextX = cur.x + dir[0];
                int nextY = cur.y + dir[1];
                /* 判断下一个节点是否越界或者已经访问过 */
                if(nextX < 0 || nextX >= maze.length || nextY < 0 || nextY >= maze[0].length || visited[nextX][nextY] || maze[nextX][nextY] == '#') continue;
                /* 添加下一个节点到队列中 */
                queue.add(new Node(nextX, nextY));
                visited[nextX][nextY] = true;
                parent[nextX][nextY] = cur;
            }
        }

        /* 输出最短路径 */
        Node cur = end;
        while(cur != start){
            System.out.print("(" + cur.x + "," + cur.y + ") <- ");
            cur = parent[cur.x][cur.y];
        }
        System.out.println("(" + start.x + "," + start.y + ")");
    }
}

以上代码是一个简单的迷宫求解问题，我们将起点和终点之间的最短路径用BFS算法求出并输出。下面对代码中的主要部分进行详解：

  1. 定义节点类
static class Node{
    int x, y;  // 节点的坐标
    Node(int x, int y){
        this.x = x;
        this.y = y;
    }
}

节点类包含一个x、y坐标，表示节点在迷宫地图中的位置。

  1. 定义队列
Queue<Node> queue = new ArrayDeque<>();
queue.add(start);

BFS算法需要使用队列来进行实现，我们使用Java标准库中的ArrayDeque来实现队列。将起点加入队列中。

  1. 定义数组记录每个节点是否被访问过
boolean[][] visited = new boolean[10][10];
visited[start.x][start.y] = true;

为了避免重复访问节点，我们需要使用一个二维布尔数组visited来记录每个节点是否被访问过。将起点标记为已访问。

  1. 定义数组记录每个节点的父节点
Node[][] parent = new Node[10][10];
parent[start.x][start.y] = start;

在搜索过程中，我们需要记录每个节点的父节点，以便在搜索结束后回溯寻找最短路径。我们使用一个二维Node数组parent来记录每个节点的父节点。将起点的父节点设置为其自身。

  1. 开始广度优先搜索
while(!queue.isEmpty()){
    /* 取出队列的头节点 */
    Node cur = queue.poll();
    /* 判断是否到达终点 */
    if(cur.x == end.x && cur.y == end.y) break;

    /* 遍历当前节点的所有邻居节点 */
    int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 定义四个方向
    for(int[] dir : dirs){
        int nextX = cur.x + dir[0];
        int nextY = cur.y + dir[1];
        /* 判断下一个节点是否越界或者已经访问过 */
        if(nextX < 0 || nextX >= maze.length || nextY < 0 || nextY >= maze[0].length || visited[nextX][nextY] || maze[nextX][nextY] == '#') continue;
        /* 添加下一个节点到队列中 */
        queue.add(new Node(nextX, nextY));
        visited[nextX][nextY] = true;
        parent[nextX][nextY] = cur;
    }
}

从队列中取出一个节点，遍历其所有邻居节点，将没有访问过的节点加入队列中，并标记其父节点。如果找到了终点，则退出循环。

  1. 输出最短路径
Node cur = end;
while(cur != start){
    System.out.print("(" + cur.x + "," + cur.y + ") <- ");
    cur = parent[cur.x][cur.y];
}
System.out.println("(" + start.x + "," + start.y + ")");

通过回溯每个节点的父节点，从终点一直走到起点，输出最短路径。

总结：

BFS算法是一种常用的图形搜索算法，它的实现需要用到队列、数组等数据结构。在使用BFS算法时，需要定义节点类、队列、visited、parent等数组或变量，然后按照广度优先的顺序逐层遍历每个节点，记录每个节点的父节点，最后回溯寻找最短路径。

在这里插入图片描述





躺平的小懒猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
广度优先算法全代码
03-15
电子老鼠闯迷宫 独轮车 六数码问题 木乃伊迷宫 跳马 找倍数
java 广度优先爬虫_浅谈网络爬虫中广度优先算法和代码实现
weixin_35932973的博客
02-13 146
前几天给大家分享了网络爬虫中深度优先算法的介绍及其代码实现过程，没来得及上车的小伙伴们可以戳这篇文章——浅谈网络爬虫中深度优先算法和简单代码实现。今天小编给大家分享网络爬虫中广度优先算法的介绍及其代码实现过程。广度优先算法和深度优先算法恰好相反，这里继续以上图的树图为例。广度优先算法的主要思想是首先从顶级域名A开始，之后从中提取出两个链接B和C，待链接B抓取完成之后，下一个要抓取的链接则是链接B的...
广度优先搜索的代码
我是小菜鸟啊。。。每天努力一点点。。。
07-17 1387
我这次还没有理解#include #include #include #include //包含队列使用 using namespace std; int dir[8][2]={{1,0},{0,1},{-1,0},{0,-1},{1,-1},{-1,1},{1,1},{-1,-1}};//同样是用dir控制方向 char G[101][101]; //存数据 bool vis[101][1
广度优先遍历代码
Norton的专栏
03-21 877
广度优先周游二叉树(层序遍历)是用队列来实现的，从二叉树的第一层（根结点）开始，自上至下逐层遍历；在同一层中，按照从左到右的顺序对结点逐一访问。 按照从根结点至叶结点、从左子树至右子树的次序访问二叉树的结点。算法：     1初始化一个队列，并把根结点入列；     2根节点入队     3循环直到队列空       3.1  q=队列头元素出队       3.2  访问q的数据域
图的广度优先算法全部代码，使用邻接矩阵，包括FirstNeighbor函数以及NextNeighbor函数的实现
强仔的博客
05-26 1233
话不多说，直接上代码，注意代码中顶点的序号是从1开始，但是存放顶点的数组序号是从0开始，所以在代码中需要实现一个函数该函数来通过顶点找到对应的下标，辅助队列使用的是带头结点的链式队列。下图来自王道考研视频，验证中也是从顶点1开始遍历，当然可以自己指定顶点进行验证。注意，边数以及顶点数也可以自己输入，我这里是直接进行赋值了，最后进行验证。
LeetCode——广度优先遍历
qq_43332536的博客
11-18 347
广度优先遍历
广度优先搜索的代码框架
Levena_的博客
03-05 574
BFS（） {        初始化队列        while（队列不为空且未找到目标节点） {                取队首节点扩展，并将扩展出的非重复节点放入队尾 ；                    必要时记住每个节点的父节点；        }}新扩展出的节点和以前扩展出的节点相同，则这个新节点就不必再考虑，如何判重？...
图的广度优先遍历（代码实现）
最新发布
qq_74074987的博客
07-05 177
【代码】图的广度优先遍历（代码实现）
c语言图的广度优先遍历(BFS遍历)和深度优先遍历(DFS遍历)示例代码
weixin_42533386的博客
09-26 4588
#include <stdio.h> #include <stdlib.h> #define MAX_VERTEX_NUM 100 // 顶点数目的最大值 #define TRUE true #define FALSE false bool visited[MAX_VERTEX_NUM]; typedef int ElemType; typedef int VertexType; // 顶点的数据类型 typedef int EdgeType;
广度优先搜索BFS代码实现
guangjie2333的博客
01-21 301
main.cpp #include<stdio.h> #include<stdlib.h> #include"BFS.h" #include"Queue.h" void main() { printf("无向图\n"); MGraph Graph; Graph = BuildGraph(); BFS(Graph,1); } Queue.h #ifndef QUE...
BFS——广度优先算法（Breadth First Search）
热门推荐
g11d111的博客
07-27 10万+
1、前言 这几天刷leetcode经常碰到DFS BFS的问题，之前一直也是模棱两可，凭着感觉做，是需要总结一下了。 广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历策略。因为它的思想是从一个顶点V0V_0开始，辐射状地优先遍历其周围较广的区域，因此得名。 一般可以用它做什么呢？一个最直观经典的例子就是走迷宫，我们从起点开始，找出到终点的最短路程，很多最短路径算
C语言：广度优先遍历算法
零小唬的博客
10-09 2526
广度优先遍历算法
搜索专题，广度优先搜索BFS详解，常见BFS问题详解及C++代码实现
weixin_45651616的博客
07-21 912
搜索专题，广度优先搜索BFS详解，常见BFS问题详解及C++代码实现
深度优先遍历和广度优先遍历代码实现
ClimberCoding
05-22 2470
图 代码主要参考：https://blog.csdn.net/weixin_40953222/article/details/80544928?spm=1001.2014.3001.5501 1. 什么是图 表示 “多对多” 的关系 包含：1. 一组顶点：通常用V(vertex) 表示顶点集合；2. 一组边：通常用E(edge) 表示边的集合。 边是定点对：(v, w)∈E，其中v, w∈V 有向边<v, w> 表示从 v 指向 w 的边（单行边） 表示方法 邻接矩阵表示法 好
广度优先搜索以及C++实现
C1172440795的博客
04-05 5925
一文带你搞懂广度优先搜索算法
广度优先遍历（一） 全排列
qq_40965678的博客
06-26 1719
（零） 广度优先遍历、回溯减枝、本质上都是树（决策树）的遍历。 Leetcode 46.全排列 原题链接 给定一个 没有重复 数字的序列，返回其所有可能的全排列。 示例: 输入: [1,2,3] 输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ] 分析：这道题有多种不同的算法，这里我利用bfs算法。 可以从数学上得全排列方法获得借鉴： 第一个数字选1，有多少中排列 第一个选2，有多少种排列 … 算法可以用一颗树来描述： 决策树的遍历 分
常见面试题的解法之二叉树（广度优先，序列化）
qq_33171875的博客
12-20 453
二叉树广度优先遍历，打印时连同行号一起打印； 解题思路： 1.初始化时，last=1，把1放入队列；2.将1出队，把1的子孩子2,3放入队列，更新nlast=3；3.nlast更新完之后，打印上一次出队的1，并和last比较，如果相同就打印换行，并更新last=nlast=3;4.将2出队，把2的子孩子4放入队列，更新nlast=4;5,nlast更新完以后，打印上一次出队的2，并和las
树与图的深度，广度优先遍历
wxy1234567890_的博客
03-25 1020
说实话，我一直不想学这一部分，因为我觉得这部分很难学，遇到的题目也很难懂，但是21年蓝桥杯 c++ b组又出了最短路问题，索性觉得我逃不过了，所以说打算花费一周的时间学习1.树与图的存储，2.树与图的深度和广度优先遍历，3.最短路的问题，次篇文章记录1和2的内容，下篇文章记录3的内容，因为内容很多。文章是看了yxc的视频之后来记录下。 1.简单介绍 首先，树在本质上就是一种图，而图又包含有向图和无向图。我们在存储图的时候，通常采用两种方式。1.邻接矩阵 2.邻接表 。 使用邻接矩阵不如使用邻接表好用（
Day_33图的广度优先遍历
DARRENANJIAN的博客
05-21 346
图的广度遍历，非常常见的算法题，在数据结构中和离散数学的图论中我们都有接触，广度遍历不需要使用递归算法，仅仅需要设置一个队列存储进出的元素即可。相信二叉树的层序遍历读者都能够理解，其实图的广度遍历就相当于稍微复杂的二叉树的层序遍历，不同是二叉树我们知道这个节点的相连的节点最多有两个节点，而图的某一个节点我们是不知道这个节点所连接的节点的个数的，所以在这里我们构造了一个访问矩阵（一维）用来存储访问过的节点，并且第二层循环里面遍历寻找一个节点的直接相连的节点。
【基础知识】一文看懂深度优先算法和广度优先算法
fumeidonga的博客
06-08 9189
先上个图现在我们要访问图中的每个节点，即图的遍历。图的遍历是指，从给定图中任意指定的顶点（称为初始点）出发，按照某种搜索方法沿着图的边访问图中的所有顶点，使每个顶点仅被访问一次，这个过程称为图的遍历。我们根据访问节点的顺序与方式（根据搜索方法），可以分为广度优先（BFS）和深度优先（DFS），这是图论中两种非常重要的算法，生产上广泛用于拓扑排序，寻路(走迷宫)，搜索引擎，爬虫等。我们分别来介绍。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值