# Print all the leaf nodes of Binary Heap

• Difficulty Level : Medium
• Last Updated : 07 Apr, 2022

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 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 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

 ``

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 :