C++——广度优先搜索

广度优先搜索（Breadth-First Search，BFS）是一种图遍历算法，它从起始节点开始逐层扩展搜索，直到找到目标节点或遍历完整个图。具体过程如下：

1、选择一个起始节点作为当前节点，并标记为已访问。

2、将当前节点加入队列。

3、从队列中取出一个节点作为当前节点，并输出该节点。

4、遍历当前节点的所有邻居节点，若邻居节点未被访问过，则标记为已访问并将其加入队列。

5、重复步骤3和步骤4，直到队列为空。

广度优先搜索通常使用队列来实现，保证按照先进先出的顺序遍历节点。它适用于解决许多图相关问题，如最短路径、连通性等。

请注意，广度优先搜索需要注意避免重复访问节点，通常使用一个额外的数组或集合来记录已访问的节点。

 

以下是使用 C++ 实现广度优先搜索（BFS）二叉树的基本代码示例：

#include <iostream>
#include <queue>
using namespace std;
// 二叉树节点定义
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int value) : val(value), left(nullptr), right(nullptr) {}
};
// 广度优先搜索函数
void BFS(TreeNode* root) {
    if (root == nullptr) {
        return;
    }

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

    while (!q.empty()) {
        TreeNode* current = q.front();
        q.pop();
        cout << current->val << " "; // 输出当前节点的值

        if (current->left) {
            q.push(current->left); // 将左子节点加入队列
        }
        if (current->right) {
            q.push(current->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->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    cout << "广度优先搜索结果：";
    BFS(root); // 执行广度优先搜索

    return 0;
}

在上述示例中，我们定义了二叉树节点的结构，并使用队列来实现广度优先搜索。首先构建了一个示例的二叉树，然后调用BFS函数执行广度优先搜索，并输出遍历的结果。

请注意，此示例提供了基本的框架，你可以根据具体需求进行适当的修改和扩展。

程序运行的结果应该是按照广度优先搜索（BFS）的顺序输出二叉树的节点值。由于广度优先搜索是逐层遍历，从根节点开始，先输出根节点的值，然后按照从左到右的顺序依次输出每一层的节点值。

假设二叉树的节点值为 1、2、3、4、5、6、7，则程序的运行结果应该是：

广度优先搜索结果：1 2 3 4 5 6 7

 

以下是使用广度优先搜索（Breadth-First Search，BFS）算法在C++中遍历图的示例代码：

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

class Graph {
private:
    int numVertices;              // 图中的节点数
    std::vector<int>* adjList;    // 邻接表

public:
    // 构造函数
    Graph(int numVertices) : numVertices(numVertices) {
        adjList = new std::vector<int>[numVertices];
    }

    // 添加边
    void addEdge(int src, int dest) {
        adjList[src].push_back(dest);
        adjList[dest].push_back(src);   // 对于无向图，需要添加反向的边
    }

    // 广度优先搜索
    void BFS(int startVertex) {
        std::vector<bool> visited(numVertices, false);   // 标记节点是否被访问
        std::queue<int> queue;                           // 用于BFS的队列

        // 将起始节点入队并标记为已访问
        queue.push(startVertex);
        visited[startVertex] = true;

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

            // 遍历当前节点的相邻节点
            for (int neighbor : adjList[currentVertex]) {
                if (!visited[neighbor]) {
                    queue.push(neighbor);
                    visited[neighbor] = true;
                }
            }
        }
    }

    // 析构函数，释放内存
    ~Graph() {
        delete[] adjList;
    }
};

int main() {
    // 创建一个包含5个节点的图
    Graph graph(5);

    // 添加边
    graph.addEdge(0, 1);
    graph.addEdge(0, 2);
    graph.addEdge(1, 3);
    graph.addEdge(2, 3);
    graph.addEdge(2, 4);
    graph.addEdge(3, 4);

    // 从节点0开始进行广度优先搜索
    std::cout << "广度优先搜索结果: ";
    graph.BFS(0);
    std::cout << std::endl;

    return 0;
}

在上述代码中，我们定义了一个Graph类来表示图。使用邻接表作为内部数据结构，使用std::vector<int>* adjList来存储图的邻接表，其中每个向量表示节点的相邻节点列表。

addEdge函数用于向图中添加边，它将目标节点添加到源节点的相邻节点列表中，并对于无向图，还需要添加反向的边。

BFS函数实现了广度优先搜索算法。它使用一个队列来辅助进行搜索，通过迭代的方式遍历图中的节点。首先，将起始节点入队并标记为已访问。然后，从队列中取出当前节点，并访问该节点。接着，遍历当前节点的相邻节点，并将未访问过的相邻节点入队。不断重复这个过程，直到队列为空。

输出结果为：

广度优先搜索结果: 0 1 2 3 4