# Prints nodes between two given level numbers in a binary tree

Time：2021-9-15

Given a binary tree and two levels of numbers “low” and “high”, print nodes from low level to high level.

``````For example consider the binary tree given in below diagram.

Input: Root of below tree, low = 2, high = 4

Output:
8 22
4 12
10 14`````` A simple method

First, write a recursive function that prints nodes with a given level number. Then recursive functions are called from low to high cycles. The time complexity of this method is O (n)

2) We can print nodes and traverse them sequentially at O (n) time using queue based iteration level. The idea is to do a simple queue based level order traversal. When performing an ordered traversal, a tag node is added at the end. Whenever we see a tag node, we increase the level number. If the level number is between low and high, the node is printed.

The following is the realization of the above idea.

## C ++

``````// A C++ program to print Nodes level by level berween given two levels.
#include <bits/stdc++.h>
using namespace std;

/* A binary tree Node has key, pointer to left and right children */
struct Node
{
int key;
struct Node* left, *right;
};

/* Given a binary tree, print nodes from level number 'low' to level
number 'high'*/
void printLevels(Node* root, int low, int high)
{
queue <Node *> Q;

Node *marker = new Node; // Marker node to indicate end of level

int level = 1;   // Initialize level number

// Enqueue the only first level node and marker node for end of level
Q.push(root);
Q.push(marker);

// Simple level order traversal loop
while (Q.empty() == false )
{
// Remove the front item from queue
Node *n = Q.front();
Q.pop();

// Check if end of level is reached
if (n == marker)
{
// print a new line and increment level number
cout << endl;
level++;

// Check if marker node was last node in queue or
// level number is beyond the given upper limit
if (Q.empty() == true || level > high) break ;

// Enqueue the marker for end of next level
Q.push(marker);

// If this is marker, then we don't need print it
// and enqueue its children
continue ;
}

// If level is equal to or greater than given lower level, // print it
if (level >= low)
cout << n->key << " " ;

// Enqueue children of non-marker node
if (n->left != NULL)  Q.push(n->left);
if (n->right != NULL) Q.push(n->right);
}
}

/* Helper function that allocates a new Node with the
given key and NULL left and right pointers. */
Node* newNode( int key)
{
Node* temp = new Node;
temp->key = key;
temp->left = temp->right = NULL;
return (temp);
}

/* Driver program to test above functions*/
int main()
{
// Let us construct the BST shown in the above figure
struct Node *root        = newNode(20);
root->left               = newNode(8);
root->right              = newNode(22);
root->left->left         = newNode(4);
root->left->right        = newNode(12);
root->left->right->left  = newNode(10);
root->left->right->right = newNode(14);

cout << "Level Order traversal between given two levels is" ;
printLevels(root, 2, 3);

return 0;
}``````

## Java

``````// Java program to print Nodes level by level between given two levels
import java.util.Queue;

/* A binary tree Node has key, pointer to left and right children */
class Node
{
int data;
Node left, right;

public Node( int item)
{
data = item;
left = right = null ;
}
}

class BinaryTree
{
Node root;

/* Given a binary tree, print nodes from level number 'low' to level
number 'high'*/
void printLevels(Node node, int low, int high)
{

Node  marker = new Node( 4 ); // Marker node to indicate end of level

int level = 1 ;   // Initialize level number

// Enqueue the only first level node and marker node for end of level

// Simple level order traversal loop
while (Q.isEmpty() == false )
{
// Remove the front item from queue
Node  n = Q.peek();
Q.remove();

// Check if end of level is reached
if (n == marker)
{
// print a new line and increment level number
System.out.println( "" );
level++;

// Check if marker node was last node in queue or
// level number is beyond the given upper limit
if (Q.isEmpty() == true || level > high)
break ;

// Enqueue the marker for end of next level

// If this is marker, then we don't need print it
// and enqueue its children
continue ;
}

// If level is equal to or greater than given lower level, // print it
if (level >= low)
System.out.print( n.data + " " );

// Enqueue children of non-marker node
if (n.left != null )

if (n.right != null )

}
}

// Driver program to test for above functions
public static void main(String args[])
{
BinaryTree tree = new BinaryTree();
tree.root = new Node( 20 );
tree.root.left = new Node( 8 );
tree.root.right = new Node( 22 );

tree.root.left.left = new Node( 4 );
tree.root.left.right = new Node( 12 );
tree.root.left.right.left = new Node( 10 );
tree.root.left.right.right = new Node( 14 );

System.out.print( "Level Order traversal between given two levels is " );
tree.printLevels(tree.root, 2 , 3 );

}
}

// This code has been contributed by Mayank Jaiswal``````

## python

``````# Python program to print nodes level by level between
# given two levels

# A binary tree node
class Node:
# Constructor tor create a new node
def __init__( self , key):
self .key = key
self .left = None
self .right = None

# Given a binary tree, print nodes form level number 'low'
# to level number 'high'

def printLevels(root, low, high):
Q = []

marker  = Node( 11114 ) # Marker node to indicate end of level

level = 1 # Initialize level number

# Enqueue the only first level node and marker node for
# end of level
Q.append(root)
Q.append(marker)

#print Q
# Simple level order traversal loop
while ( len (Q) > 0 ):
# Remove the front item from queue
n = Q[ 0 ]
Q.pop( 0 )
#print Q
# Check if end of level is reached
if n = = marker:
# print a new line and increment level number
print
level + = 1

# Check if marker node was last node in queue
# or level nubmer is beyond the given upper limit
if len (Q) = = 0 or level > high:
break

# Enqueue the marker for end of next level
Q.append(marker)

# If this is marker, then we don't need print it
# and enqueue its children
continue
if level > = low:
print n.key, # Enqueue children of non-marker node
if n.left is not None :
Q.append(n.left)
Q.append(n.right)

# Driver program to test the above function
root = Node( 20 )
root.left = Node( 8 )
root.right = Node( 22 )
root.left.left = Node( 4 )
root.left.right = Node( 12 )
root.left.right.left = Node( 10 )
root.left.right.right = Node( 14 )

print "Level Order Traversal between given two levels is" , printLevels(root, 2 , 3 )

# This code is contributed by Nikhil Kumar Singh(nickzuck_007)``````

## C

``````using System;
using System.Collections.Generic;

// c# program to print Nodes level by level between given two levels

/* A binary tree Node has key, pointer to left and right children */
public class Node
{
public int data;
public Node left, right;

public Node( int item)
{
data = item;
left = right = null ;
}
}

public class BinaryTree
{
public Node root;

/* Given a binary tree, print nodes from level number 'low' to level
number 'high'*/
public virtual void printLevels(Node node, int low, int high)
{

Node marker = new Node(4); // Marker node to indicate end of level

int level = 1; // Initialize level number

// Enqueue the only first level node and marker node for end of level

// Simple level order traversal loop
while (Q.Count > 0)
{
// Remove the front item from queue
Node n = Q.First.Value;
Q.RemoveFirst();

// Check if end of level is reached
if (n == marker)
{
// print a new line and increment level number
Console.WriteLine( "" );
level++;

// Check if marker node was last node in queue or
// level number is beyond the given upper limit
if (Q.Count == 0 || level > high)
{
break ;
}

// Enqueue the marker for end of next level

// If this is marker, then we don't need print it
// and enqueue its children
continue ;
}

// If level is equal to or greater than given lower level, // print it
if (level >= low)
{
Console.Write(n.data + " " );
}

// Enqueue children of non-marker node
if (n.left != null )
{
}

if (n.right != null )
{
}

}
}

// Driver program to test for above functions
public static void Main( string [] args)
{
BinaryTree tree = new BinaryTree();
tree.root = new Node(20);
tree.root.left = new Node(8);
tree.root.right = new Node(22);

tree.root.left.left = new Node(4);
tree.root.left.right = new Node(12);
tree.root.left.right.left = new Node(10);
tree.root.left.right.right = new Node(14);

Console.Write( "Level Order traversal between given two levels is " );
tree.printLevels(tree.root, 2, 3);

}
}

// This code is contributed by Shrikant13``````

The output is as follows

``````Level Order traversal between given two levels is
8 22
4 12``````

The time complexity of the above method is O (n) because it performs a simple hierarchical sequential traversal.