Skip to content
Related Articles

Related Articles

Print Leaf Nodes at a given Level

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Easy
  • Last Updated : 06 Aug, 2021

Given a Binary tree, print all the leaf nodes of a Binary tree at a given level L.
Examples:

Input:    
           1
          /  \
         2    3
        /    /  \
       4    5    6
 level = 3

Output: 4 5 6

Input:    
             7
            /  \
           2    3
          / \    \
         4   9   10
                 /
                6
   level = 3

Output: 4 9

Approach: Recursively traverse the tree in a level order manner. If the current level is the same as the given level, then check whether the current node is a leaf node or not. If it is a leaf node then print it.
Below is the implementation of the above approach: 
 

C++




// C++ program to print all the
// leaf nodes at a given level
// in a Binary tree
#include <bits/stdc++.h>
using namespace std;
 
// Binary tree node
struct node {
    struct node* left;
    struct node* right;
    int data;
};
 
// Function to create a new
// Binary node
struct node* newNode(int data)
{
    struct node* temp = new node;
 
    temp->data = data;
    temp->left = NULL;
    temp->right = NULL;
 
    return temp;
}
 
// Function to print Leaf Nodes at
// a given level
void PrintLeafNodes(struct node* root, int level)
{
    if (root == NULL)
        return;
 
    if (level == 1) {
        if (root->left == NULL && root->right == NULL)
            cout << root->data << " ";
    }
    else if (level > 1) {
        PrintLeafNodes(root->left, level - 1);
        PrintLeafNodes(root->right, level - 1);
    }
}
 
// Driver code
int main()
{
    struct node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(6);
    root->right->right = newNode(4);
    root->left->left->left = newNode(8);
    root->left->left->right = newNode(7);
 
    int level = 4;
 
    PrintLeafNodes(root, level);
 
    return 0;
}

Java




// Java program to print all the
// leaf nodes at a given level
// in a Binary tree
class GFG
{
 
    // Binary tree node
    static class node
    {
 
        node left;
        node right;
        int data;
    };
 
    // Function to create a new
    // Binary node
    static node newNode(int data)
    {
        node temp = new node();
 
        temp.data = data;
        temp.left = null;
        temp.right = null;
 
        return temp;
    }
 
    // Function to print Leaf Nodes at
    // a given level
    static void PrintLeafNodes(node root, int level)
    {
        if (root == null)
        {
            return;
        }
 
        if (level == 1)
        {
            if (root.left == null && root.right == null)
            {
                System.out.print(root.data + " ");
            }
 
        }
        else if (level > 1)
        {
            PrintLeafNodes(root.left, level - 1);
            PrintLeafNodes(root.right, level - 1);
        }
    }
 
    // Driver code
    public static void main(String[] args)
    {
        node root = newNode(1);
        root.left = newNode(2);
        root.right = newNode(3);
        root.left.left = newNode(6);
        root.right.right = newNode(4);
        root.left.left.left = newNode(8);
        root.left.left.right = newNode(7);
 
        int level = 4;
 
        PrintLeafNodes(root, level);
    }
}
 
// This code contributed by Rajput-Ji

Python3




# Python3 program to print all the
# leaf nodes at a given level
# in a Binary tree
 
# Binary tree node
class node:
     
    def __init__(self, data):
        self.left=None
        self.right=None
        self.data=data
  
# Function to create a new
# Binary node
def newNode(data):
    return node(data)
  
# Function to print Leaf Nodes at
# a given level
def PrintLeafNodes(root, level):
    if (root == None):
        return
  
    if (level == 1):
        if (root.left == None and
            root.right == None):
            print(root.data, end = " ")
     
    elif (level > 1):
        PrintLeafNodes(root.left, level - 1)
        PrintLeafNodes(root.right, level - 1)
         
if __name__=="__main__":
     
    root=newNode(1)
    root.left = newNode(2);
    root.right = newNode(3);
    root.left.left = newNode(6);
    root.right.right = newNode(4);
    root.left.left.left = newNode(8);
    root.left.left.right = newNode(7);
    level = 4;
    PrintLeafNodes(root, level);
 
# This code is contributed by rutvik_56

C#




// C# program to print all the
// leaf nodes at a given level
// in a Binary tree
using System;
 
class GFG
{
 
    // Binary tree node
    public class node
    {
 
        public node left;
        public node right;
        public int data;
    };
 
    // Function to create a new
    // Binary node
    static node newNode(int data)
    {
        node temp = new node();
 
        temp.data = data;
        temp.left = null;
        temp.right = null;
 
        return temp;
    }
 
    // Function to print Leaf Nodes at
    // a given level
    static void PrintLeafNodes(node root, int level)
    {
        if (root == null)
        {
            return;
        }
 
        if (level == 1)
        {
            if (root.left == null && root.right == null)
            {
                Console.Write(root.data + " ");
            }
 
        }
        else if (level > 1)
        {
            PrintLeafNodes(root.left, level - 1);
            PrintLeafNodes(root.right, level - 1);
        }
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        node root = newNode(1);
        root.left = newNode(2);
        root.right = newNode(3);
        root.left.left = newNode(6);
        root.right.right = newNode(4);
        root.left.left.left = newNode(8);
        root.left.left.right = newNode(7);
 
        int level = 4;
 
        PrintLeafNodes(root, level);
    }
}
 
// This code has been contributed by 29AjayKumar

Javascript




<script>
 
    // JavaScript program to print all the
    // leaf nodes at a given level
    // in a Binary tree
     
    // Binary tree node
    class node
    {
        constructor(data) {
           this.left = null;
           this.right = null;
           this.data = data;
        }
    }
     
    // Function to create a new
    // Binary node
    function newNode(data)
    {
        let temp = new node(data);
  
        temp.data = data;
        temp.left = null;
        temp.right = null;
  
        return temp;
    }
  
    // Function to print Leaf Nodes at
    // a given level
    function PrintLeafNodes(root, level)
    {
        if (root == null)
        {
            return;
        }
  
        if (level == 1)
        {
            if (root.left == null && root.right == null)
            {
                document.write(root.data + " ");
            }
  
        }
        else if (level > 1)
        {
            PrintLeafNodes(root.left, level - 1);
            PrintLeafNodes(root.right, level - 1);
        }
    }
     
    let root = newNode(1);
    root.left = newNode(2);
    root.right = newNode(3);
    root.left.left = newNode(6);
    root.right.right = newNode(4);
    root.left.left.left = newNode(8);
    root.left.left.right = newNode(7);
 
    let level = 4;
 
    PrintLeafNodes(root, level);
 
</script>

Output: 

8 7

 

Time Complexity:O(N) where N is the number of nodes in a binary tree.
Auxiliary Space: O(N) 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!