Print the nodes corresponding to the level value for each level of a Binary Tree
Given a Binary Tree, the task for each level L is to print the Lth node of the tree. If the Lth node is not present for any level, print -1.
Note: Consider the root node to be at the level 1 of the binary tree.
Examples:
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.
Approach: To solve this problem the idea is to use Multimap. Follow the steps below to solve the problem:
- Traverse the given tree and store the level of each node and the node’s value in the Multimap.
- The levels of the nodes are considered as the key of the multimap. Keep track of the maximum level of the Binary Tree(say L).
- Now, iterate the Multimap over the range [1, L] and perform the following operations:
- For each level L, traverse till the Lth node of that level check if it exists or not. If found to be existing, print the value of that node.
- Otherwise, print “-1” and proceed to the next level.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
multimap< int , int > m;
int maxlevel = 0;
struct node {
int data;
struct node* left;
struct node* right;
};
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;
}
void findNode( struct node* root, int level)
{
if (root) {
findNode(root->left, level + 1);
m.insert({ level, root->data });
maxlevel = max(maxlevel, level);
findNode(root->right, level + 1);
}
}
void printNode( struct node* root, int level)
{
findNode(root, level);
multimap< int , int >::iterator it;
for ( int i = 0; i <= maxlevel; i++) {
cout << "Level " << i + 1 << ": " ;
it = m.find(i);
int flag = 0;
for ( int j = 0; j < i; j++) {
it++;
if (it == m.end()) {
flag = 1;
break ;
}
}
if (flag == 1 || it->first != i) {
cout << "-1" << endl;
}
else {
cout << it->second << endl;
}
}
}
int main()
{
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);
printNode(root, 0);
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
static HashMap<Integer,ArrayList<Integer>> m = new HashMap<>();
static int maxlevel = 0 ;
static class node {
int data;
node left;
node right;
}
static node newnode( int d)
{
node temp = new node();
temp.left = null ;
temp.right = null ;
temp.data = d;
return temp;
}
static void findNode(node root, int level)
{
if (root!= null ) {
findNode(root.left, level + 1 );
if (m.get(level)== null ){
m.put(level, new ArrayList<Integer>());
}
m.get(level).add(root.data);
maxlevel = Math.max(maxlevel, level);
findNode(root.right, level + 1 );
}
}
static void printNode(node root, int level)
{
findNode(root, level);
for ( int i = 0 ; i <= maxlevel; i++) {
System.out.print( "Level " + (i + 1 ) + ": " );
List<Integer> it = m.get(i);
int flag = 0 ;
if (it.size()<i){
flag= 1 ;
System.out.print( "-1\n" );
} else {
System.out.print(it.get(i)+ "\n" );
}
}
}
public static void main (String[] args) {
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 );
printNode(root, 0 );
}
}
|
Python3
from collections import defaultdict
m = defaultdict( list )
maxlevel = 0
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def newnode(d):
temp = Node(d)
return temp
def findNode(root, level):
if root:
findNode(root.left, level + 1 )
m[level].append(root.data)
global maxlevel
maxlevel = max (maxlevel, level)
findNode(root.right, level + 1 )
def printNode(root, level):
findNode(root, level)
for i in range (maxlevel + 1 ):
print ( "Level {}: " . format (i + 1 ), end = "")
if i not in m:
print ( "-1" )
else :
print (m[i][i])
if __name__ = = "__main__" :
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 )
printNode(root, 0 )
|
C#
using System;
using System.Collections.Generic;
public class node {
public int data;
public node left;
public node right;
}
public class GFG {
static Dictionary< int , List< int > > m
= new Dictionary< int , List< int > >();
static int maxlevel = 0;
static node newnode( int d)
{
node temp = new node();
temp.left = null ;
temp.right = null ;
temp.data = d;
return temp;
}
static void findNode(node root, int level)
{
if (root != null )
{
findNode(root.left, level + 1);
if (!m.ContainsKey(level)) {
m.Add(level, new List< int >());
}
m[level].Add(root.data);
maxlevel = Math.Max(maxlevel, level);
findNode(root.right, level + 1);
}
}
static void printNode(node root, int level)
{
findNode(root, level);
for ( int i = 0; i <= maxlevel; i++) {
Console.Write( "Level " + (i + 1) + ": " );
List< int > it = m[i];
int flag = 0;
if (it.Count < i) {
flag = 1;
Console.WriteLine( "-1" );
}
else {
Console.WriteLine(it[i]);
}
}
}
static public void Main()
{
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);
printNode(root, 0);
}
}
|
Javascript
const m = new Map();
let maxlevel = 0;
class Node {
constructor(data) {
this .data = data;
this .left = null ;
this .right = null ;
}
}
function newnode(d) {
return new Node(d);
}
function findNode(root, level) {
if (root) {
findNode(root.left, level + 1);
if (!m.has(level)) {
m.set(level, [root.data]);
} else {
m.get(level).push(root.data);
}
maxlevel = Math.max(maxlevel, level);
findNode(root.right, level + 1);
}
}
function printNode(root, level) {
findNode(root, level);
for (let i = 0; i <= maxlevel; i++) {
console.log( "Level " + (i + 1) + ": " , m.has(i) ? m.get(i)[i] : -1);
}
}
const 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);
printNode(root, 0);
|
Output:
Level 1: 1
Level 2: 3
Level 3: 6
Level 4: 12
Time Complexity: O(N), where N is the number of nodes in the Binary Tree.
Auxiliary Space: O(N)
Efficient Approach(using Queue):
Follow the below steps to solve this problem:
1) Perform level order traversal and keep track of level at each node.
2) At each level check if the level number is greater than number of elements in the queue then print
“-1” else print node which is at level number in current level by comparing level number of nodes pop from queue.
Below is the implementation of above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* left;
struct Node* right;
};
struct Node* newnode( int d){
Node* temp = new Node();
temp->data = d;
temp->left = NULL;
temp->right = NULL;
return temp;
}
void printNode(Node* root){
int level = 1;
queue<Node*> q;
q.push(root);
while (!q.empty()){
int n = q.size();
if (level > n) cout<< "Level " <<level<< " : " << "-1" <<endl;
for ( int i = 0; i<n; i++){
Node* temp = q.front();
q.pop();
if (i == level-1){
cout<< "Level " <<level<< " : " <<temp->data<<endl;
}
if (temp->left) q.push(temp->left);
if (temp->right) q.push(temp->right);
}
level++;
}
}
int main()
{
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);
printNode(root);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class Node {
int data;
Node left;
Node right;
Node( int data)
{
this .data = data;
this .left = null ;
this .right = null ;
}
}
class GFG {
static void printNode(Node root)
{
int level = 1 ;
Queue<Node> q = new LinkedList<>();
q.add(root);
while (!q.isEmpty()) {
int n = q.size();
if (level > n)
System.out.println( "Level " + level + " : "
+ "-1" );
for ( int i = 0 ; i < n; i++) {
Node temp = q.poll();
if (i == level - 1 ) {
System.out.println( "Level " + level
+ " : " + temp.data);
}
if (temp.left != null )
q.add(temp.left);
if (temp.right != null )
q.add(temp.right);
}
level++;
}
}
public static void main(String[] args)
{
Node root = new Node( 1 );
root.left = new Node( 2 );
root.right = new Node( 3 );
root.left.left = new Node( 4 );
root.left.right = new Node( 5 );
root.left.right.left = new Node( 11 );
root.left.right.right = new Node( 12 );
root.left.left.left = new Node( 9 );
root.left.left.right = new Node( 10 );
root.right.left = new Node( 6 );
root.right.right = new Node( 7 );
root.right.right.left = new Node( 13 );
root.right.right.right = new Node( 14 );
printNode(root);
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def newnode(d):
return Node(d)
def printNode(root):
level = 1
q = []
q.append(root)
while ( len (q) > 0 ):
n = len (q)
if (level > n):
print ( "Level" , level, " : -1" )
for i in range (n):
temp = q.pop( 0 )
if (i = = level - 1 ):
print ( "Level" , level , " : " , temp.data)
if (temp.left is not None ):
q.append(temp.left)
if (temp.right is not None ):
q.append(temp.right)
level + = 1
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 );
printNode(root)
|
Javascript
class Node{
constructor(data){
this .data = data;
this .left = null ;
this .right = null ;
}
}
function newnode(d){
return new Node(d);
}
function printNode(root){
let level = 1;
let q = [];
q.push(root);
while (q.length > 0){
let n = q.length;
if (level > n) console.log( "Level " + level + " : " << "-1" );
for (let i = 0; i<n; i++){
let temp = q.shift();
if (i == level-1){
console.log( "Level " + level + " : " + temp.data);
}
if (temp.left) q.push(temp.left);
if (temp.right) q.push(temp.right);
}
level++;
}
}
let 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);
printNode(root);
|
C#
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left;
public Node right;
public Node( int data)
{
this .data = data;
this .left = null ;
this .right = null ;
}
}
public class GFG {
static void printNode(Node root)
{
int level = 1;
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
while (q.Count > 0) {
int n = q.Count;
if (level > n)
Console.WriteLine( "Level " + level + " : "
+ "-1" );
for ( int i = 0; i < n; i++) {
Node temp = q.Dequeue();
if (i == level - 1) {
Console.WriteLine( "Level " + level
+ " : " + temp.data);
}
if (temp.left != null )
q.Enqueue(temp.left);
if (temp.right != null )
q.Enqueue(temp.right);
}
level++;
}
}
static public void Main()
{
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.left.right.left = new Node(11);
root.left.right.right = new Node(12);
root.left.left.left = new Node(9);
root.left.left.right = new Node(10);
root.right.left = new Node(6);
root.right.right = new Node(7);
root.right.right.left = new Node(13);
root.right.right.right = new Node(14);
printNode(root);
}
}
|
Output
Level 1 : 1
Level 2 : 3
Level 3 : 6
Level 4 : 12
Time Complexity: O(N) where N is the number of nodes in given binary tree.
Auxiliary Space: O(b) where b is the maximum width of given binary tree due to queue data structure.
Last Updated :
27 Mar, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...