Skip to content

Iterative HeapSort

How to check if a given array represents a Binary Heap?

Last Updated : 15 Dec, 2022

Try it on GfG Practice

Given an array, how to check if the given array represents a Binary Max-Heap.
Examples:

Input:  arr[] = {90, 15, 10, 7, 12, 2}   Output: True  The given array represents below tree         90       /    \     15      10    /  \     /   7    12  2   The tree follows max-heap property as every  node is greater than all of its descendants.    Input:  arr[] = {9, 15, 10, 7, 12, 11}   Output: False  The given array represents below tree         9       /    \     15      10    /  \     /   7    12  11  The tree doesn't follows max-heap property 9 is   smaller than 15 and 10, and 10 is smaller than 11.

Recommended PracticeDoes array represent HeapTry It!

A Simple Solution is to first check root if it’s greater than all of its descendants. Then check for children of the root. Time complexity of this solution is O(n²)

An Efficient Solution is to compare root only with its children (not all descendants), if root is greater than its children and the same is true for all nodes, then tree is max-heap (This conclusion is based on transitive property of > operator, i.e., if x > y and y > z, then x > z).
The last internal node is present at index (n-2)/2 assuming that indexing begins with 0.

Below is the implementation of this solution.

C++

   // C program to check whether a given array 
// represents a max-heap or not 
#include <limits.h> 
#include <stdio.h> 
  
// Returns true if arr[i..n-1] represents a 
// max-heap 
bool isHeap(int arr[], int i, int n) 
{ 
    // If (2 * i) + 1 >= n, then leaf node, so return true 
    if (i >= (n - 1) / 2) 
        return true; 
  
    // If an internal node and is  
    // greater than its children, 
    // and same is recursively  
    // true for the children 
    if (arr[i] >= arr[2 * i + 1] &&  
        arr[i] >= arr[2 * i + 2] 
        && isHeap(arr, 2 * i + 1, n) 
        && isHeap(arr, 2 * i + 2, n)) 
        return true; 
  
    return false; 
} 
  
// Driver program 
int main() 
{ 
    int arr[] = { 90, 15, 10, 7, 12, 2, 7, 3 }; 
    int n = sizeof(arr) / sizeof(int) - 1; 
  
    isHeap(arr, 0, n) ? printf("Yes") : printf("No"); 
  
    return 0; 
}
 
  

Java

   // Java program to check whether a given array 
// represents a max-heap or not 
class GFG  
{ 
  
    // Returns true if arr[i..n-1]  
    // represents a max-heap 
    static boolean isHeap(int arr[],  
                          int i, int n) 
    { 
        // If (2 * i) + 1 >= n, then leaf node, so return true 
        if (i >= (n - 1) / 2)  
        { 
            return true; 
        } 
  
        // If an internal node and  
        // is greater than its 
        // children, and same is  
        // recursively true for the 
        // children 
        if (arr[i] >= arr[2 * i + 1] 
            && arr[i] >= arr[2 * i + 2] 
            && isHeap(arr, 2 * i + 1, n) 
            && isHeap(arr, 2 * i + 2, n))  
        { 
            return true; 
        } 
  
        return false; 
    } 
  
    // Driver program 
    public static void main(String[] args) 
    { 
        int arr[] = { 90, 15, 10, 7, 12, 2, 7, 3 }; 
        int n = arr.length - 1; 
        if (isHeap(arr, 0, n)) { 
            System.out.println("Yes"); 
        } 
        else { 
            System.out.println("No"); 
        } 
    } 
} 
  
// This code contributed by 29AjayKumar
 
  

Python3

   # Python3 program to check whether a  
# given array represents a max-heap or not  
  
# Returns true if arr[i..n-1]  
# represents a max-heap  
def isHeap(arr, i, n): 
      
    # If (2 * i) + 1 >= n, then leaf node, so return true 
    if i >= int((n - 1) / 2):  
        return True
      
    # If an internal node and is greater  
    # than its children, and same is 
    # recursively true for the children  
    if(arr[i] >= arr[2 * i + 1] and 
       arr[i] >= arr[2 * i + 2] and 
       isHeap(arr, 2 * i + 1, n) and
       isHeap(arr, 2 * i + 2, n)): 
        return True
      
    return False
  
# Driver Code 
if __name__ == '__main__': 
    arr = [90, 15, 10, 7, 12, 2, 7, 3]  
    n = len(arr) - 1
  
    if isHeap(arr, 0, n): 
        print("Yes") 
    else: 
        print("No") 
  
# This code is contributed by PranchalK 
 
  

C#

   // C# program to check whether a given   
// array represents a max-heap or not 
using System; 
  
class GFG 
{ 
  
// Returns true if arr[i..n-1] represents a  
// max-heap  
static bool isHeap(int []arr, int i, int n)  
{ 
    // If (2 * i) + 1 >= n, then leaf node, so return true 
    if (i >= (n - 1) / 2)  
    { 
        return true; 
    } 
  
    // If an internal node and is greater  
    // than its children, and same is  
    // recursively true for the children  
    if (arr[i] >= arr[2 * i + 1] &&  
        arr[i] >= arr[2 * i + 2] &&  
        isHeap(arr, 2 * i + 1, n) &&  
        isHeap(arr, 2 * i + 2, n))  
    { 
        return true; 
    } 
  
    return false; 
} 
  
// Driver Code  
public static void Main(String[] args) 
{ 
    int []arr = {90, 15, 10, 7, 12, 2, 7, 3}; 
    int n = arr.Length-1; 
    if (isHeap(arr, 0, n)) 
    { 
        Console.Write("Yes"); 
    }  
      
    else
    { 
        Console.Write("No"); 
    } 
} 
} 
 
  

PHP

   <?php 
// PHP program to check whether a given  
// array represents a max-heap or not 
  
// Returns true if arr[i..n-1]  
// represents a max-heap 
function isHeap($arr, $i, $n) 
{ 
      
// If (2 * i) + 1 >= n, then leaf node, so return true 
if ($i >= ($n - 1) / 2) 
    return true; 
  
// If an internal node and is greater  
// than its children, and same is  
// recursively true for the children 
if ($arr[$i] >= $arr[2 * $i + 1] &&  
    $arr[$i] >= $arr[2 * $i + 2] &&  
    isHeap($arr, 2 * $i + 1, $n) &&  
    isHeap($arr, 2 * $i + 2, $n)) 
    return true; 
  
return false; 
} 
  
// Driver Code 
$arr = array(90, 15, 10, 7, 12, 2, 7, 3); 
$n = sizeof($arr); 
  
if(isHeap($arr, 0, $n)) 
    echo "Yes"; 
else
    echo "No"; 
  
// This code is contributed  
// by Akanksha Rai 
?> 
 
  

Javascript

   <script> 
// Javascript program to check whether a given array 
// represents a max-heap or not 
  
// Returns true if arr[i..n-1] 
    // represents a max-heap 
function isHeap(arr,i,n) 
{ 
    // If (2 * i) + 1 >= n, then leaf node, so return true 
        if (i >= (n - 1) / 2) 
        { 
            return true; 
        } 
   
        // If an internal node and 
        // is greater than its 
        // children, and same is 
        // recursively true for the 
        // children 
        if (arr[i] >= arr[2 * i + 1] 
            && arr[i] >= arr[2 * i + 2] 
            && isHeap(arr, 2 * i + 1, n) 
            && isHeap(arr, 2 * i + 2, n)) 
        { 
            return true; 
        } 
   
        return false; 
} 
  
// Driver program 
let arr=[ 90, 15, 10, 7, 12, 2, 7, 3 ]; 
let n = arr.length - 1; 
if (isHeap(arr, 0, n)) { 
    document.write("Yes<br>"); 
} 
else { 
    document.write("No<br>"); 
} 
  
  
// This code is contributed by rag2127 
</script> 
 
  

Output

Yes

Time complexity: O(n)
Auxiliary Space: O(h), Here h is the height of the given tree and the extra space is used due to the recursion call stack.

An Iterative Solution is to traverse all internal nodes and check id the node is greater than its children or not.

C++

   // C program to check whether a given array 
// represents a max-heap or not 
#include <stdio.h> 
#include <limits.h> 
  
// Returns true if arr[i..n-1] represents a 
// max-heap 
bool isHeap(int arr[],  int n) 
{ 
    // Start from root and go till the last internal 
    // node 
    for (int i=0; i<=(n-2)/2; i++) 
    { 
        // If left child is greater, return false 
        if (arr[2*i +1] > arr[i]) 
                return false; 
  
        // If right child is greater, return false 
        if (2*i+2 < n && arr[2*i+2] > arr[i]) 
                return false; 
    } 
    return true; 
} 
  
// Driver program 
int main() 
{ 
    int arr[] = {90, 15, 10, 7, 12, 2, 7, 3}; 
    int n = sizeof(arr) / sizeof(int); 
  
    isHeap(arr, n)? printf("Yes"): printf("No"); 
  
    return 0; 
} 
 
  

Java

   // Java program to check whether a given array  
// represents a max-heap or not 
  
class GFG { 
  
// Returns true if arr[i..n-1] represents a  
// max-heap  
    static boolean isHeap(int arr[], int n) { 
        // Start from root and go till the last internal  
        // node  
        for (int i = 0; i <= (n - 2) / 2; i++) { 
            // If left child is greater, return false  
            if (arr[2 * i + 1] > arr[i]) { 
                return false; 
            } 
  
            // If right child is greater, return false  
            if (2 * i + 2 < n && arr[2 * i + 2] > arr[i]) { 
                return false; 
            } 
        } 
        return true; 
    } 
  
// Driver program  
    public static void main(String[] args) { 
        int arr[] = {90, 15, 10, 7, 12, 2, 7, 3}; 
        int n = arr.length; 
        if (isHeap(arr, n)) { 
            System.out.println("Yes"); 
        } else { 
            System.out.println("No"); 
        } 
    } 
} 
// This code is contributed by 29AjayKumar 
 
  

Python3

   # Python3 program to check whether a  
# given array represents a max-heap or not  
  
# Returns true if arr[i..n-1]  
# represents a max-heap  
def isHeap(arr, n): 
      
    # Start from root and go till  
    # the last internal node 
    for i in range(int((n - 2) / 2) + 1): 
          
        # If left child is greater,  
        # return false  
        if arr[2 * i + 1] > arr[i]:  
                return False
  
        # If right child is greater, 
        # return false  
        if (2 * i + 2 < n and
            arr[2 * i + 2] > arr[i]):  
                return False
    return True
  
# Driver Code 
if __name__ == '__main__': 
    arr = [90, 15, 10, 7, 12, 2, 7, 3]  
    n = len(arr) 
  
    if isHeap(arr, n): 
        print("Yes") 
    else: 
        print("No") 
          
# This code is contributed by PranchalK 
 
  

C#

   // C# program to check whether a given array  
// represents a max-heap or not  
using System; 
  
class GFG  
{ 
  
// Returns true if arr[i..n-1]  
// represents a max-heap  
static bool isHeap(int []arr, int n) 
{  
    // Start from root and go till  
    // the last internal node  
    for (int i = 0; i <= (n - 2) / 2; i++)  
    {  
        // If left child is greater,  
        // return false  
        if (arr[2 * i + 1] > arr[i]) 
        {  
            return false;  
        }  
  
        // If right child is greater,  
        // return false  
        if (2 * i + 2 < n && arr[2 * i + 2] > arr[i])  
        {  
            return false;  
        }  
    }  
    return true;  
}  
  
// Driver Code  
public static void Main()  
{  
    int []arr = {90, 15, 10, 7, 12, 2, 7, 3};  
    int n = arr.Length;  
    if (isHeap(arr, n)) 
    {  
        Console.Write("Yes");  
    }  
    else 
    {  
        Console.Write("No");  
    }  
}  
}  
  
// This code is contributed  
// by 29AjayKumar 
 
  

PHP

   <?php 
// PHP program to check whether a  
// given array represents a max-heap or not  
  
// Returns true if arr[i..n-1]  
// represents a max-heap  
function isHeap($arr, $i, $n)  
{ 
    // Start from root and go till  
    // the last internal node  
    for ($i = 0; $i < (($n - 2) / 2) + 1; $i++)  
    { 
        // If left child is greater,  
        // return false  
        if($arr[2 * $i + 1] > $arr[$i])  
                return False; 
  
        // If right child is greater,  
        // return false  
        if (2 * $i + 2 < $n &&  
                $arr[2 * $i + 2] > $arr[$i]) 
                return False; 
      
    return True; 
    } 
} 
  
// Driver Code  
$arr = array(90, 15, 10, 7, 12, 2, 7, 3);  
$n = sizeof($arr);  
  
if(isHeap($arr, 0, $n))  
    echo "Yes";  
else
    echo "No"; 
      
// This code is contributed by Princi Singh 
?> 
 
  

Javascript

   <script> 
  
// Javascript program to check 
// whether a given array 
// represents a max-heap or not 
  
// Returns true if arr[i..n-1]  
// represents a max-heap 
function isHeap( arr, n) 
{ 
    // Start from root and go till  
    // the last internal node 
    for (let i=0; i<=Math.floor((n-2)/2); i++) 
    { 
        // If left child is greater,  
        // return false 
        if (arr[2*i +1] > arr[i]) 
                return false; 
  
        // If right child is greater, 
        // return false 
        if (2*i+2 < n && arr[2*i+2] > arr[i]) 
                return false; 
    } 
    return true; 
} 
    // driver code  
      
    let arr = [90, 15, 10, 7, 12, 2, 7, 3]; 
    let n = arr.length; 
    if (isHeap(arr, n)) { 
        document.write("Yes"); 
        }  
    else { 
        document.write("No"); 
        } 
      
</script>
 
  

Output

Yes

Time complexity: O(n), Where n is the total number of elements in the given array.
Auxiliary Space: O(1), As constant extra space is used.

Thanks to Himanshu for suggesting this solution.

Iterative HeapSort

kartik

Improve

Article Tags :

Practice Tags :

Similar Reads

Heap Data Structure

A Heap is a complete binary tree data structure that satisfies the heap property: for every node, the value of its children is greater than or equal to its own value. Heaps are usually used to implement priority queues, where the smallest (or largest) element is always at the root of the tree. Basic

Introduction to Heap - Data Structure and Algorithm Tutorials

A Heap is a special Tree-based Data Structure that has the following properties. It is a Complete Binary Tree.It either follows max heap or min heap property.Max-Heap: The value of the root node must be the greatest among all its descendant nodes and the same thing must be done for its left and righ

A Binary Heap is a complete binary tree that stores data efficiently, allowing quick access to the maximum or minimum element, depending on the type of heap. It can either be a Min Heap or a Max Heap. In a Min Heap, the key at the root must be the smallest among all the keys in the heap, and this pr

Advantages and Disadvantages of Heap

Advantages of Heap Data StructureTime Efficient: Heaps have an average time complexity of O(log n) for inserting and deleting elements, making them efficient for large datasets. We can convert any array to a heap in O(n) time. The most important thing is, we can get the min or max in O(1) timeSpace

Time Complexity of building a heap

Consider the following algorithm for building a Heap of an input array A. A quick look over the above implementation suggests that the running time is [Tex]O(n * lg(n)) [/Tex] since each call to Heapify costs [Tex]O(lg(n)) [/Tex]and Build-Heap makes [Tex]O(n) [/Tex]such calls. This upper bound, thou

Applications of Heap Data Structure

Heap Data Structure is generally taught with Heapsort. Heapsort algorithm has limited uses because Quicksort is better in practice. Nevertheless, the Heap data structure itself is enormously used. Priority Queues: Heaps are commonly used to implement priority queues, where elements with higher prior

Comparison between Heap and Tree

What is Heap? A Heap is a special Tree-based data structure in which the tree is a complete binary tree. Types of Heap Data Structure: Generally, Heaps can be of two types: Max-Heap: In a Max-Heap the key present at the root node must be greatest among the keys present at all of its children. The sa

When building a Heap, is the structure of Heap unique?

What is Heap? A heap is a tree based data structure where the tree is a complete binary tree that maintains the property that either the children of a node are less than itself (max heap) or the children are greater than the node (min heap). Properties of Heap: Structural Property: This property sta