Skip to content
Related Articles

Related Articles

Print all the leaf nodes of Binary Heap

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 07 Apr, 2022
View Discussion
Improve Article
Save Article

Given an array of N elements which denotes the array representation of binary heap, the task is to find the leaf nodes of this binary heap.

Examples: 

Input: 
arr[] = {1, 2, 3, 4, 5, 6, 7}
Output: 4 5 6 7
Explanation:
             1
           /   \
          2     3
         / \   / \
        4   5 6   7
Leaf nodes of the Binary Heap are:
4 5 6 7
         
Input: 
arr[] = {1, 2, 3, 4, 5,
         6, 7, 8, 9, 10}
Output: 6 7 8 9 10
Explanation:
                1
             /     \
            2       3
          /   \    / \
         4      5 6   7
       /   \   /
      8     9 10
Leaf Nodes of the Binary Heap are:
6 7 8 9 10
 

Approach: The key observation in the problem is that the every leaf node of the Binary  Heap will be at the Height H or H -1, If H is the height of the Binary Heap. Therefore, the leaf nodes can be computed as follows:

  • Calculate the total height of the binary heap.
  • Traverse the array in reverse order and compare the height of each node to the compute height H of the Binary Heap.
  • If the height of the current node is H, then add the current node to the leaf nodes.
  • Otherwise, If the height of current node is H-1 and there are no child nodes, then also add the node as leaf node.

Below is the implementation of the above approach:

Java




// Java implementation to print
// the leaf nodes of a Binary Heap
 
import java.lang.*;
import java.util.*;
class GFG {
 
    // Function to calculate height
    // of the Binary heap with given
    // the count of the nodes
    static int height(int N)
    {
        return (int)Math.ceil(
                   Math.log(N + 1)
                   / Math.log(2))
            - 1;
    }
 
    // Function to find the leaf
    // nodes of binary heap
    static void findLeafNodes(
        int arr[], int n)
    {
        // Calculate the height of
        // the complete binary tree
        int h = height(n);
 
        ArrayList<Integer> arrlist
            = new ArrayList<>();
 
        for (int i = n - 1; i >= 0; i--) {
            if (height(i + 1) == h) {
                arrlist.add(arr[i]);
            }
            else if (height(i + 1) == h - 1
                     && n <= ((2 * i) + 1)) {
 
                // if the height if h-1,
                // then there should not
                // be any child nodes
                arrlist.add(arr[i]);
            }
            else {
                break;
            }
        }
        printLeafNodes(arrlist);
    }
 
    // Function to print the leaf nodes
    static void printLeafNodes(
        ArrayList<Integer> arrlist)
    {
        for (int i = arrlist.size() - 1;
             i >= 0; i--) {
            System.out.print(
                arrlist.get(i) + " ");
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 3, 4, 5,
                      6, 7, 8, 9, 10 };
        findLeafNodes(arr, arr.length);
    }
}


C#




// C# implementation to print
// the leaf nodes of a Binary Heap
using System;
using System.Collections.Generic;
class GFG{
 
// Function to calculate height
// of the Binary heap with given
// the count of the nodes
static int height(int N)
{
    return (int)Math.Ceiling(
                Math.Log(N + 1) /
                Math.Log(2)) - 1;
}
 
// Function to find the leaf
// nodes of binary heap
static void findLeafNodes(int []arr,
                          int n)
{
    // Calculate the height of
    // the complete binary tree
    int h = height(n);
 
    List<int> arrlist = new List<int>();
 
    for (int i = n - 1; i >= 0; i--)
    {
        if (height(i + 1) == h)
        {
            arrlist.Add(arr[i]);
        }
        else if (height(i + 1) == h - 1 &&
                 n <= ((2 * i) + 1))
        {
 
            // if the height if h-1,
            // then there should not
            // be any child nodes
            arrlist.Add(arr[i]);
        }
        else
        {
            break;
        }
    }
    printLeafNodes(arrlist);
}
 
// Function to print the leaf nodes
static void printLeafNodes(List<int> arrlist)
{
    for (int i = arrlist.Count - 1; i >= 0; i--)
    {
        Console.Write(arrlist[i] + " ");
    }
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 1, 2, 3, 4, 5,
                  6, 7, 8, 9, 10 };
    findLeafNodes(arr, arr.Length);
}
}
 
// This code is contributed by Princi Singh


Python3




# Python3 implementation to print
# the leaf nodes of a Binary Heap
import math
 
def height(N):
 
    return math.log(N + 1) // math.log(2)
   
# Function to find the leaf
# nodes of binary heap
def findLeafNodes(arr, n):
 
    # Calculate the height of
    # the complete binary tree
    h = height(n)
     
    arrlist = []
   
    for i in range(n - 1,-1,-1):
        if (height(i + 1) == h):
            arrlist.append(arr[i])
        elif (height(i + 1) == h - 1 and n <= ((2 * i) + 1)):
   
            # if the height if h-1,
            # then there should not
            # be any child nodes
            arrlist.append(arr[i])
        else:
            break
 
    prLeafNodes(arrlist)
   
# Function to pr the leaf nodes
def prLeafNodes(arrlist):
 
    for i in range(len(arrlist) - 1,-1,-1):
        print(arrlist[i],end=" ")
   
# Driver Code
arr = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
findLeafNodes(arr, len(arr))
 
# This code is contributed by shinjanpatra


Javascript




<script>
// JavaScript implementation to print
// the leaf nodes of a Binary Heap
function height(N){
 
    return Math.floor(Math.log(N + 1) / Math.log(2))
}
   
// Function to find the leaf
// nodes of binary heap
function findLeafNodes(arr, n){
 
    // Calculate the height of
    // the complete binary tree
    let h = height(n)
     
    let arrlist = []
   
    for(let i = n - 1;i >= 0 ;i--){
        if (height(i + 1) == h)
            arrlist.push(arr[i])
        else if (height(i + 1) == h - 1 && n <= ((2 * i) + 1))
   
            // if the height if h-1,
            // then there should not
            // be any child nodes
            arrlist.push(arr[i])
        else
            break
    }
 
    prLeafNodes(arrlist)
}
   
// Function to pr the leaf nodes
function prLeafNodes(arrlist){
 
    for(let i = arrlist.length - 1 ; i>=-0; i--)
        document.write(arrlist[i]," ")
}
   
// Driver Code
 
let arr = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
findLeafNodes(arr, arr.length)
 
// This code is contributed by shinjanpatra
 
</script>


Output:

6 7 8 9 10

Performance Analysis:

  • Time Complexity: O(L), where L is the number of leaf nodes.
  • Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!