Print all nodes between two given levels in Binary Tree

Given a binary tree, print all nodes between two given levels in a binary tree. Print the nodes level wise, i.e., the nodes for any level should be printed from left to right.

In the above tree, if starting level is 2 and ending level is 3 then solution should print:

2 3 
4 5 6 7 

Note: Level number starts with 1. That is, the root node is at level 1.

Prerequisite: Level order Traversal.

The idea is to do level order traversal of the tree using a queue and keep track of the current level. If the current level lies between the starting and ending level then print the nodes at that level.

Algorithm:

levelordertraverse (root, startLevel, endLevel)
q -> empty queue
q.enqueue (root)
level -> 0
while (not q.isEmpty())
     size -> q.size()
     level = level + 1
     while (size)
          node -> q.dequeue()
          if (level between startLevel and endevel)
               print (node)
           if(node.leftnull)
                q.enqueue (node. left)
           if(node.leftnull)
                q.enqueue(node.right)
           size =size -1

Below is the implementation of the above algorithm:

Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for Print all nodes
// between two given levels in
// a binary tree
  
import java.util.LinkedList;
import java.util.Queue;
  
public class BinaryTree {
  
    // Class containing left and right
    // child of current node and key value
    static class Node {
  
        int data;
        Node left, right;
  
        public Node(int item)
        {
            data = item;
            left = right = null;
        }
    }
  
    // Root of the Binary Tree
    Node root;
    public BinaryTree()
    {
        root = null;
    }
  
    // Iterative function to print all
    // nodes between two given
    // levels in a binary tree
    void printNodes(Node root, int start, int end)
    {
        if (root == null) {
            return;
        }
  
        // create an empty queue and
        // enqueue root node
        Queue<Node> queue = new LinkedList<Node>();
        queue.add(root);
  
        // pointer to store current node
        Node curr = null;
  
        // maintains level of current node
        int level = 0;
  
        // run till queue is not empty
        while (!queue.isEmpty()) {
            // increment level by 1
            level++;
  
            // calculate number of nodes in
            // current level
            int size = queue.size();
  
            // process every node of current level
            // and enqueue their non-empty left
            // and right child to queue
            while (size != 0) {
                curr = queue.peek();
                queue.poll();
  
                // print the node if its level is
                // between given levels
                if (level >= start && level <= end) {
                    System.out.print(curr.data + " ");
                }
                if (curr.left != null) {
                    queue.add(curr.left);
                }
  
                if (curr.right != null) {
                    queue.add(curr.right);
                }
                size--;
            }
  
            if (level >= start && level <= end) {
                System.out.println("");
            };
        }
    }
  
    // Driver Code
    public static void main(String args[])
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);
        tree.root.right.left = new Node(6);
        tree.root.right.right = new Node(7);
  
        /* Constructed binary tree is 
             
           /  \ 
          2    3 
         / \  / \
        4   5 6  7 */
  
        int start = 2, end = 3;
  
        tree.printNodes(tree.root, start, end);
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for Print all nodes
# between two given levels in
# a binary tree 
  
# Helper function that allocates a new 
# node with the given data and None 
# left and right poers.                                 
class newNode: 
  
    # Construct to create a new node 
    def __init__(self, key): 
        self.data = key
        self.left = None
        self.right = None
  
# Iterative function to pr all
# nodes between two given
# levels in a binary tree
def prNodes(root, start, end):
      
    if (root == None): 
        return
  
    # create an empty queue and
    # enqueue root node
    q = []
    q.append(root)
  
    # poer to ste current node
    curr = None
  
    # maains level of current node
    level = 0
  
    # run till queue is not empty
    while (len(q)): 
          
        # increment level by 1
        level += 1
  
        # calculate number of nodes in
        # current level
        size = len(q)
  
        # process every node of current level
        # and enqueue their non-empty left
        # and right child to queue
        while (size != 0) :
            curr = q[0]
            q.pop(0)
  
            # pr the node if its level is
            # between given levels
            if (level >= start and level <= end) :
                print(curr.data, end = " ")
              
            if (curr.left != None) :
                q.append(curr.left)
              
            if (curr.right != None) :
                q.append(curr.right)
              
            size -= 1
          
        if (level >= start and level <= end) :
            print("")
              
# Driver Code 
if __name__ == '__main__':
      
    """ 
    Let us create Binary Tree shown
    in above example """
    root = newNode(1)
    root.left = newNode(2)
  
    root.left.left = newNode(4)
    root.left.right = newNode(5)
    root.right = newNode(3)
    root.right.right = newNode(7)
    root.right.left = newNode(6)
    start = 2
    end = 3
    prNodes(root, start, end)
      
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for Print all nodes 
// between two given levels in 
// a binary tree 
using System;
using System.Collections.Generic; 
  
public class BinaryTree 
{
  
    // Class containing left and right 
    // child of current node and key value 
    public class Node 
    {
  
        public int data;
        public Node left, right;
  
        public Node(int item)
        {
            data = item;
            left = right = null;
        }
    }
  
    // Root of the Binary Tree 
    Node root;
  
    public BinaryTree() 
    {
        root = null;
    }
  
    // Iterative function to print all 
    // nodes between two given 
    // levels in a binary tree 
    void printNodes(Node root, int start, int end) 
    {
        if (root == null
        {
            return;
        }
  
        // create an empty queue and 
        // enqueue root node 
        Queue<Node> queue = new Queue<Node>();
        queue.Enqueue(root);
  
        // pointer to store current node 
        Node curr = null;
  
        // maintains level of current node 
        int level = 0;
  
        // run till queue is not empty 
        while (queue.Count >0) 
        {
            // increment level by 1 
            level++;
  
            // calculate number of nodes in 
            // current level 
            int size = queue.Count;
  
            // process every node of current level 
            // and enqueue their non-empty left 
            // and right child to queue 
            while (size != 0)
            {
                curr = queue.Peek();
                queue.Dequeue();
  
                // print the node if its level is 
                // between given levels 
                if (level >= start && level <= end)
                {
                    Console.Write(curr.data + " ");
                }
                if (curr.left != null
                {
                    queue.Enqueue(curr.left);
                }
  
                if (curr.right != null
                {
                    queue.Enqueue(curr.right);
                }
                size--;
            }
  
            if (level >= start && level <= end) 
            {
                Console.WriteLine("");
            };
        }
    }
  
    // Driver Code 
    public static void Main(String []args) 
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);
        tree.root.right.left = new Node(6);
        tree.root.right.right = new Node(7);
  
        /* Constructed binary tree is 
            
        / \ 
        2 3 
        / \ / \ 
        4 5 6 7 */
        int start = 2, end = 3;
  
        tree.printNodes(tree.root, start, end);
    }
}
  
// This code is contributed by 29AjayKumar

chevron_right


Output:

2 3 
4 5 6 7


My Personal Notes arrow_drop_up

Strategy Path planning and Destination matters in success No need to worry about in between temporary failures

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.