Related Articles
Print nodes between two given level numbers of a binary tree
• Difficulty Level : Medium
• Last Updated : 11 Feb, 2020

Given a binary tree and two level numbers ‘low’ and ‘high’, print nodes from level low to level high.

```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 is to first write a recursive function that prints nodes of a given level number. Then call recursive function in a loop from low to high. Time complexity of this method is O(n2)
We can print nodes in O(n) time using queue based iterative level order traversal. The idea is to do simple queue based level order traversal. While doing inorder traversal, add a marker node at the end. Whenever we see a marker node, we increase level number. If level number is between low and high, then print nodes.

The following is the implementation of above idea.

## C++

 `// A C++ program to print Nodes level by level berween given two levels.``#include ``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 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.LinkedList;``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) ``    ``{``        ``Queue Q = ``new` `LinkedList<>();``  ` `        ``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``        ``Q.add(node);``        ``Q.add(marker);``  ` `        ``// 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``                ``Q.add(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)``                ``System.out.print( n.data + ``" "``);`` ` `            ``// Enqueue children of non-marker node``            ``if` `(n.left != ``null``)``                ``Q.add(n.left);``             ` `            ``if` `(n.right != ``null``) ``                ``Q.add(n.right);``             ` `        ``}``    ``}``  ` `    ``// 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)``    ``{``        ``LinkedList Q = ``new` `LinkedList();`` ` `        ``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 ``        ``Q.AddLast(node);``        ``Q.AddLast(marker);`` ` `        ``// 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 ``                ``Q.AddLast(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)``            ``{``                ``Console.Write(n.data + ``" "``);``            ``}`` ` `            ``// Enqueue children of non-marker node ``            ``if` `(n.left != ``null``)``            ``{``                ``Q.AddLast(n.left);``            ``}`` ` `            ``if` `(n.right != ``null``)``            ``{``                ``Q.AddLast(n.right);``            ``}`` ` `        ``}``    ``}`` ` `    ``// 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`

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

Time complexity of above method is O(n) as it does a simple level order traversal.