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

给定二叉树，每个级别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)