C++实现树和图的广度优先搜索

广度优先搜索（Breadth-First Search，BFS）是一种用于遍历或搜索图或树的算法。它从起始节点开始，首先访问起始节点的所有邻接节点，然后依次访问这些邻接节点的邻接节点，直到遍历完所有可达节点。广度优先搜索一般使用队列来实现。

广度优先搜索通常用于解决以下问题：

1. 图的连通性：通过广度优先搜索可以判断图中两个节点之间是否存在路径。

2. 最短路径：通过广度优先搜索可以找到图中两个节点之间的最短路径。

3. 图的最小生成树：通过广度优先搜索可以生成图的最小生成树。

4. 解决迷宫问题：通过广度优先搜索可以在迷宫中找到从起点到终点的最短路径。

广度优先搜索的基本思想可以用以下步骤来描述：

1. 从起始节点开始，将起始节点加入队列，并标记为已访问。

2. 从队列中取出一个节点，访问该节点的所有未被访问的邻接节点，并将这些邻接节点加入队列，并标记为已访问。

3. 重复步骤 2，直到队列为空。

广度优先搜索保证了在同一层级中，先访问到的节点会比后访问到的节点的深度浅。因此，它也可以用来求解一些最短路径问题。

广度优先搜索的实现通常需要使用一个队列来保存待访问的节点。当需要访问节点的邻接节点时，将这些邻接节点加入队列中。然后，从队列中取出一个节点进行访问，直到队列为空为止。

下面是一个使用C++实现广度优先搜索（BFS）的示例，针对树的结构进行搜索。

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

// 树节点的定义
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 广度优先搜索函数
void bfs(TreeNode* root) {
    if (root == NULL) return;

    queue<TreeNode*> q;
    q.push(root);

    while (!q.empty()) {
        TreeNode* node = q.front();
        q.pop();
        cout << node->val << " ";

        if (node->left != NULL) q.push(node->left);
        if (node->right != NULL) q.push(node->right);
    }
}

int main() {
    // 构造树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->right = new TreeNode(6);

    // 广度优先搜索
    cout << "Breadth First Traversal: ";
    bfs(root);
    cout << endl;

    return 0;
}

在这个示例中，我们首先定义了一个树节点的结构 TreeNode，包含一个整数值和左右子节点指针。

在 bfs 函数中，我们使用队列来实现广度优先搜索。首先将根节点入队，然后进入循环，从队列中取出一个节点，输出它的值，并将其所有未访问的子节点加入队列中，直到队列为空。

在 main 函数中，我们构造了一个示例树，并调用 bfs 函数来进行广度优先搜索。

输出结果将会是：

Breadth First Traversal: 1 2 3 4 5 6

这个结果符合预期，根据广度优先搜索的性质，我们按照广度优先的顺序遍历了树的所有节点。

下面是一个使用C++实现广度优先搜索（BFS）的示例，针对图的结构进行搜索。

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

// 图的邻接表表示
class Graph {
private:
    int V; // 图中顶点的数量
    vector<unordered_set<int>> adj; // 邻接表

public:
    // 构造函数，初始化图的顶点数量和邻接表
    Graph(int V) : V(V), adj(V) {}

    // 添加边
    void addEdge(int u, int v) {
        adj[u].insert(v);
        adj[v].insert(u); // 无向图需要加上这一行
    }

    // 广度优先搜索函数
    void bfs(int start) {
        vector<bool> visited(V, false); // 记录顶点是否被访问过的数组
        queue<int> q; // 用于存储待访问的顶点的队列

        visited[start] = true; // 标记起始顶点为已访问
        q.push(start); // 将起始顶点入队

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

            // 访问当前顶点的所有未被访问的邻接顶点，并将其加入队列中
            for (int neighbor : adj[cur]) {
                if (!visited[neighbor]) {
                    visited[neighbor] = true;
                    q.push(neighbor);
                }
            }
        }
    }
};

int main() {
    // 创建一个图对象
    Graph graph(6);
    
    // 添加边
    graph.addEdge(0, 1);
    graph.addEdge(0, 2);
    graph.addEdge(1, 3);
    graph.addEdge(2, 4);
    graph.addEdge(2, 5);

    // 进行广度优先搜索
    cout << "Breadth First Traversal: ";
    graph.bfs(0); // 从节点0开始进行广度优先搜索
    cout << endl;

    return 0;
}

在这个示例中，我们首先定义了一个名为 Graph 的类，用于表示图结构，并实现了添加边和广度优先搜索的功能。我们使用邻接表来表示图，其中 adj 是一个 vector，每个元素是一个 unordered_set，用于存储每个顶点的邻接顶点。

在 bfs 函数中，我们使用队列来实现广度优先搜索。首先将起始顶点入队，并标记为已访问，然后进入循环，从队列中取出一个顶点，访问它的所有未访问的邻接顶点，并将这些邻接顶点入队，并标记为已访问，直到队列为空。

在 main 函数中，我们创建了一个示例图，并添加了一些边，然后调用 bfs 函数进行广度优先搜索。

输出结果将会是：

Breadth First Traversal: 0 1 2 3 4 5

这个结果符合预期，根据广度优先搜索的性质，我们按照广度优先的顺序遍历了图的所有顶点。