Метод 1: использование очереди
Один из наиболее распространенных подходов к обходу порядка уровней — использование структуры данных очереди. Вот пример реализации:

#include <iostream>
#include <queue>
struct Node {
    int data;
    Node* left;
    Node* right;
};
void levelOrderTraversal(Node* root) {
    if (root == nullptr)
        return;
    std::queue<Node*> q;
    q.push(root);
    while (!q.empty()) {
        Node* current = q.front();
        q.pop();
        std::cout << current->data << " ";
        if (current->left)
            q.push(current->left);
        if (current->right)
            q.push(current->right);
    }
}

Метод 2: использование рекурсии и параметра глубины
Другой метод предполагает использование рекурсии и параметра глубины для отслеживания текущего уровня. Вот пример реализации:

#include <iostream>
struct Node {
    int data;
    Node* left;
    Node* right;
};
void printGivenLevel(Node* root, int level) {
    if (root == nullptr)
        return;
    if (level == 1)
        std::cout << root->data << " ";
    else if (level > 1) {
        printGivenLevel(root->left, level - 1);
        printGivenLevel(root->right, level - 1);
    }
}
int height(Node* node) {
    if (node == nullptr)
        return 0;
    else {
        int leftHeight = height(node->left);
        int rightHeight = height(node->right);
        return (leftHeight > rightHeight) ? (leftHeight + 1) : (rightHeight + 1);
    }
}
void levelOrderTraversal(Node* root) {
    int h = height(root);
    for (int i = 1; i <= h; i++)
        printGivenLevel(root, i);
}

Метод 3: использование вектора очередей
Альтернативный подход — использовать вектор очередей, где каждая очередь представляет уровень в дереве. Вот пример реализации:

#include <iostream>
#include <queue>
#include <vector>
struct Node {
    int data;
    Node* left;
    Node* right;
};
void levelOrderTraversal(Node* root) {
    if (root == nullptr)
        return;
    std::vector<std::queue<Node*>> levels(1);
    levels[0].push(root);
    int depth = 0;
    while (!levels[depth].empty()) {
        std::queue<Node*>& currentLevel = levels[depth];
        std::queue<Node*> nextLevel;
        while (!currentLevel.empty()) {
            Node* current = currentLevel.front();
            currentLevel.pop();
            std::cout << current->data << " ";
            if (current->left)
                nextLevel.push(current->left);
            if (current->right)
                nextLevel.push(current->right);
        }
        depth++;
        levels.push_back(nextLevel);
    }
}