打印与二叉树每个级别的级别值对应的节点

给定一个二叉树，每层L的任务是打印树的^第L 个节点。如果第L^个节点不存在于任何级别，则打印-1 。

注意：考虑根节点位于二叉树的第 1 级。

例子：

Input: Below is the given Tree:

Output:
Level 1: 1
Level 2: 3
Level 3: 6
Level 4: 11
Explanation:
For the first level, the 1st node is 1. 
For the second level, the 2nd node is 3.
For the third level, the 3rd node is 6.
For the fourth level, the 4th node is 11.

Input: Below is the given Tree:

Output:
Level 1: 1
Level 2: 3
Level 3: 6
Level 4: -1
Explanation:
For the first level, the 1st node is 1. 
For the second level, the 2nd node is 3.
For the third level, the 3rd node is 6.
For the fourth level, the 4th node is not available. Hence, print -1.

方法：解决这个问题的想法是使用Multimap。请按照以下步骤解决问题：

1. 遍历给定的树并将每个节点的级别和节点的值存储在Multimap 中。
2. 节点的级别被认为是多图的关键。跟踪二叉树的最大级别(比如L )。
3. 现在，在范围[1, L] 上迭代 Multimap 并执行以下操作：
   • 对于每个级别L ，遍历直到该级别的第 L^个节点检查它是否存在。如果发现存在，则打印该节点的值。
   • 否则，打印“-1”并继续下一级别。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
  
// Stores the level of the node and
// its value at the max level of BT
multimap m;
  
// Stores the maximum level
int maxlevel = 0;
  
// Structure of Binary Tree
struct node {
  
    int data;
    struct node* left;
    struct node* right;
};
  
// Function to insert the node in
// the Binary Tree
struct node* newnode(int d)
{
    struct node* temp
        = (struct node*)malloc(
            sizeof(struct node));
    temp->data = d;
    temp->left = NULL;
    temp->right = NULL;
    return temp;
}
  
// Function to find node of Nth level
void findNode(struct node* root, int level)
{
    // If root exists
    if (root) {
  
        // Traverse left subtree
        findNode(root->left, level + 1);
  
        // Insert the node's level and
        // its value into the multimap
        m.insert({ level, root->data });
  
        // Update the maximum level
        maxlevel = max(maxlevel, level);
  
        // Traverse the right subtree
        findNode(root->right, level + 1);
    }
}
  
// Function to print the L-th node at
// L-th level of the Binary Tree
void printNode(struct node* root, int level)
{
    // Function Call
    findNode(root, level);
  
    // Iterator for traversing map
    multimap::iterator it;
  
    // Iterate all the levels
    for (int i = 0; i <= maxlevel; i++) {
  
        // Print the current level
        cout << "Level " << i + 1 << ": ";
  
        it = m.find(i);
        int flag = 0;
  
        // Iterate upto i-th node of the
        // i-th level
        for (int j = 0; j < i; j++) {
  
            it++;
  
            // If end of the level
            // is reached
            if (it == m.end()) {
                flag = 1;
                break;
            }
        }
  
        // If i-th node does not exist
        // in the i-th level
        if (flag == 1 || it->first != i) {
            cout << "-1" << endl;
        }
  
        // Otherwise
        else {
  
            // Print the i-th node
            cout << it->second << endl;
        }
    }
}
  
// Driver code
int main()
{
    // Construct the Binary Tree
    struct node* root = newnode(1);
    root->left = newnode(2);
    root->right = newnode(3);
  
    root->left->left = newnode(4);
    root->left->right = newnode(5);
  
    root->left->right->left = newnode(11);
    root->left->right->right = newnode(12);
    root->left->left->left = newnode(9);
    root->left->left->right = newnode(10);
    root->right->left = newnode(6);
    root->right->right = newnode(7);
    root->right->right->left = newnode(13);
    root->right->right->right = newnode(14);
  
    // Function Call
    printNode(root, 0);
}

输出：

Level 1: 1
Level 2: 3
Level 3: 6
Level 4: 12

时间复杂度： O(N)，其中 N 是二叉树中的节点数。
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live