C++BFS广度优先搜索全解

原创已于 2026-05-09 19:18:46 修改 · 244 阅读

4 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#c++ #宽度优先 #算法

于 2026-05-07 12:47:30 首次发布

从零开始教你一步步学好C++ 专栏收录该内容

29 篇文章

订阅专栏

广度优先搜索（BFS）基础概念

广度优先搜索是一种用于遍历或搜索树或图的算法。它从根节点开始，逐层访问所有相邻节点，直到找到目标节点或遍历完整个结构。BFS通常使用队列数据结构来实现，确保先访问的节点先被处理。

BFS的核心思想是“先进先出”（FIFO），即最早被发现的节点最先被扩展。这种特性使得BFS适合解决最短路径问题，尤其是在无权图中，因为BFS能够保证第一次访问到某个节点时，路径是最短的。

BFS算法实现步骤

BFS的实现通常分为以下几个部分：初始化队列、标记访问节点、处理当前节点、扩展相邻节点。以下是C++中BFS的基本代码框架：

#include <queue>
#include <vector>
using namespace std;

void bfs(int start, vector<vector<int>>& graph) {
    queue<int> q;
    vector<bool> visited(graph.size(), false);
    q.push(start);
    visited[start] = true;

    while (!q.empty()) {
        int current = q.front();
        q.pop();
        // 处理当前节点
        for (int neighbor : graph[current]) {
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                q.push(neighbor);
            }
        }
    }
}

BFS的应用场景

BFS广泛应用于图论和树结构的问题中，尤其是在无权图中寻找最短路径。以下是一些典型的应用场景：

无权图的最短路径：BFS可以找到从起点到其他所有节点的最短路径。
连通性检测：判断图中两个节点是否连通。
层次遍历：在树或图中按层次遍历节点。
迷宫求解：在二维矩阵中寻找从起点到终点的最短路径。
社交网络分析：例如查找两个人之间的最短关系链。

BFS的优化与变种

BFS可以通过一些优化手段提高效率或适应特定问题：

双向BFS：从起点和终点同时进行BFS，减少搜索空间。
A*算法：结合启发式函数的BFS，用于带权图的最短路径问题。
多源BFS：从多个起点同时开始BFS，用于解决某些特定问题。

BFS的复杂度分析

BFS的时间复杂度和空间复杂度通常为O(V + E)，其中V是节点数，E是边数。这是因为每个节点和每条边最多被访问一次。空间复杂度主要来自队列和访问标记数组，最坏情况下需要存储所有节点。

BFS与DFS的比较

BFS和深度优先搜索（DFS）是两种最常用的图遍历算法，各有优缺点：

BFS：适合寻找最短路径，但空间复杂度较高。
DFS：空间复杂度较低，但可能陷入深层搜索而无法找到最短路径。

BFS的C++代码示例

以下是一个完整的BFS代码示例，用于在无向图中遍历所有节点：

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

void bfs(int start, vector<vector<int>>& graph) {
    queue<int> q;
    vector<bool> visited(graph.size(), false);
    q.push(start);
    visited[start] = true;

    while (!q.empty()) {
        int current = q.front();
        q.pop();
        cout << current << " ";
        for (int neighbor : graph[current]) {
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                q.push(neighbor);
            }
        }
    }
}

int main() {
    int n = 5; // 节点数
    vector<vector<int>> graph(n);
    graph[0] = {1, 2};
    graph[1] = {0, 3, 4};
    graph[2] = {0};
    graph[3] = {1};
    graph[4] = {1};

    cout << "BFS traversal starting from node 0: ";
    bfs(0, graph);
    cout << endl;
    return 0;
}

BFS在二维矩阵中的应用

BFS常用于解决二维矩阵中的迷宫或路径问题。以下是一个示例代码，用于在矩阵中寻找从起点到终点的最短路径：

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};

int bfs(vector<vector<int>>& grid, pair<int, int> start, pair<int, int> end) {
    int rows = grid.size();
    int cols = grid[0].size();
    queue<pair<int, int>> q;
    vector<vector<int>> dist(rows, vector<int>(cols, -1));
    q.push(start);
    dist[start.first][start.second] = 0;

    while (!q.empty()) {
        auto current = q.front();
        q.pop();
        if (current == end) {
            return dist[current.first][current.second];
        }
        for (int i = 0; i < 4; ++i) {
            int nx = current.first + dx[i];
            int ny = current.second + dy[i];
            if (nx >= 0 && nx < rows && ny >= 0 && ny < cols && grid[nx][ny] == 0 && dist[nx][ny] == -1) {
                dist[nx][ny] = dist[current.first][current.second] + 1;
                q.push({nx, ny});
            }
        }
    }
    return -1;
}

int main() {
    vector<vector<int>> grid = {
        {0, 1, 0, 0},
        {0, 0, 0, 1},
        {1, 1, 0, 0},
        {0, 0, 0, 0}
    };
    pair<int, int> start = {0, 0};
    pair<int, int> end = {3, 3};
    int shortestPath = bfs(grid, start, end);
    cout << "Shortest path length: " << shortestPath << endl;
    return 0;
}

BFS的常见错误与调试

在实现BFS时，容易出现以下错误：

未标记访问节点：导致重复访问和无限循环。
队列处理顺序错误：可能导致结果不正确。
边界条件未处理：例如矩阵越界或空图情况。

调试时可以通过打印队列状态和访问标记来检查算法的执行过程。

BFS的扩展学习

要进一步掌握BFS，可以尝试以下练习：

实现双向BFS。
解决LeetCode上的BFS相关题目，如“二叉树的层次遍历”、“岛屿数量”等。
学习如何使用BFS解决状态空间搜索问题，例如八数码问题。

BFS是算法学习中的重要基础，掌握其原理和实现对于解决复杂问题至关重要。