📌  相关文章
📜  为二叉树的每个级别打印与级别值相对应的节点

📅  最后修改于: 2021-04-27 20:38:54             🧑  作者: Mango

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

注意:认为根节点位于二叉树的级别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)