广度优先搜索（BFS）算法实现二叉树层序遍历的 C++ 代码

#include <iostream> // 输入输出流
#include <vector> // 向量容器
#include <queue> // 队列容器

using namespace std; // 命名空间

// 定义二叉树节点结构体
struct TreeNode {
    int val; // 节点值
    TreeNode* left; // 左子节点指针
    TreeNode* right; // 右子节点指针
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} // 构造函数
};

// 定义二叉树层序遍历函数，返回一个二维向量
vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>> res; // 定义结果向量
    if (root == nullptr) { // 特殊情况处理：根节点为空
        return res; // 返回空结果向量
    }

    queue<TreeNode*> q; // 定义队列，用于 BFS 遍历
    q.push(root); // 根节点入队

    while (!q.empty()) { // 循环遍历队列中的节点
        int level_size = q.size(); // 当前层节点数
        vector<int> level; // 定义当前层节点值向量
        for (int i = 0; i < level_size; i++) { // 循环遍历当前层的所有节点
            TreeNode* node = q.front(); // 获取队列头部节点
            q.pop(); // 弹出队列头部节点
            level.push_back(node->val); // 将节点值加入当前层节点值向量
            if (node->left != nullptr) { // 如果左子节点不为空，则入队
                q.push(node->left);
            }
            if (node->right != nullptr) { // 如果右子节点不为空，则入队
                q.push(node->right);
            }
        }
        res.push_back(level); // 将当前层节点值向量加入结果向量
    }

    return res; // 返回结果向量
}

// 主函数
int main() {
    // 构造二叉树
    TreeNode* root = new TreeNode(3);
    root->left = new TreeNode(9);
    root->right = new TreeNode(20);
    root->right->left = new TreeNode(15);
    root->right->right = new TreeNode(7);

    // 调用二叉树层序遍历函数
    vector<vector<int>> res = levelOrder(root);

    // 输出结果
    for (vector<int> level : res) { // 循环遍历结果向量的每一层
        for (int val : level) { // 循环遍历每一层的所有节点值
            cout << val << " "; // 输出节点值并加上空格
        }
        cout << endl; // 换行
    }

    return 0; // 结束程序
}

在这个示例代码中，我们首先定义了一个 TreeNode 结构体表示树的节点。levelOrder 函数接受一个树的根节点，并返回一个二维向量，其中每个子向量表示树的一层节点的值。我们首先判断根节点是否为空，如果为空则返回一个空向量。然后我们创建一个队列，并将根节点入队。接着，我们执行一个循环，在每次循环中处理当前队列中的所有节点。在处理每个节点时，我们将该节点的值加入到当前层的向量中，并将该节点的子节点入队。循环结束后，我们将当前层的向量加入到结果向量中，并重复以上操作直到队列为空。最后，我们返回结果向量即可。

该算法的时间复杂度为 O(N)，其中 N 是树的节点数。在最坏情况下，即当树是一颗平衡二叉树时，队列的长度会达到最大值，即 N/2，因此空间复杂度为 O(N)。