Check if an Array is Max Heap

Given an array arr[], determine whether it represents a valid binary max heap. Return true if it does; otherwise, return false.

Examples: 

Input: arr[] = [90, 15, 10, 7, 12, 2]
Output: true
Explanation: 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
Explanation: The tree doesn't follows max-heap property 9 is smaller than 15 and 10, and 10 is smaller than 11.

[Naive Approach] Recursive Approach - O(n) Time and O(Log n) Space

• We compare compare each node with its immediate children, not all descendants.
• If every node is greater than or equal to its children, then by the transitive property (if x > y and y > z, then x > z), the whole tree satisfies the max-heap property.
• The children of index i are at 2 i + 1 and 2 i + 2. A node will have children only if 2 i + 1 < n, which gives i ≤ (n − 2)/2. So, we traverse only up to index (n − 2)/2 because nodes after that are leaf nodes and do not have children, preventing out-of-bounds.

Algorithm:

• Start from root and recursively check each node: it must be ≥ its left child (2i+1) and right child (2i+2).
• Stop when reaching leaf nodes (i > (n-2)/2); if all checks pass, the array represents a max-heap.

#include <iostream>
#include <vector>
using namespace std;

bool isHeapUtil(vector<int>& arr, int i, int n)
{
    // If leaf node
    if (i >= n / 2)
        return true;

    int left = 2 * i + 1;
    int right = 2 * i + 2;

    // Check left child
    if (arr[i] < arr[left])
        return false;

    // Check right child only if exists
    if (right < n && arr[i] < arr[right])
        return false;

    // Recurse
    return isHeapUtil(arr, left, n) &&
           (right >= n || isHeapUtil(arr, right, n));
}

bool isMaxHeap(vector<int>& arr)
{
    return isHeapUtil(arr, 0, arr.size());
}

int main()
{
    vector<int> arr = {90, 15, 10, 7, 12, 2, 7, 3};
    isMaxHeap(arr) ? cout << "true" : cout << "false";
    return 0;
}

import java.util.Arrays;

class GfG {
    public static boolean isHeapUtil(int[] arr, int i, int n) {

        // If leaf node
        if (i >= n / 2)
            return true;

        int left = 2 * i + 1;
        int right = 2 * i + 2;

        // Check left child
        if (arr[i] < arr[left])
            return false;

        // Check right child only if exists
        if (right < n && arr[i] < arr[right])
            return false;

        // Recurse
        return isHeapUtil(arr, left, n) &&
               (right >= n || isHeapUtil(arr, right, n));
    }

    public static boolean isMaxHeap(int[] arr) {
        return isHeapUtil(arr, 0, arr.length);
    }

    public static void main(String[] args) {
        int[] arr = {90, 15, 10, 7, 12, 2, 7, 3};
        System.out.println(isMaxHeap(arr) ? "true" : "false");
    }
}

def isHeapUtil(arr, i, n):
    # If leaf node
    if i >= n // 2:
        return True

    left = 2 * i + 1
    right = 2 * i + 2

    # Check left child
    if arr[i] < arr[left]:
        return False

    # Check right child only if exists
    if right < n and arr[i] < arr[right]:
        return False

    # Recurse
    return isHeapUtil(arr, left, n) and (
        right >= n or isHeapUtil(arr, right, n))


def isMaxHeap(arr):
    return isHeapUtil(arr, 0, len(arr))

if __name__ == "__main__":
    arr = list(map(int, input().split()))
    print("true" if isMaxHeap(arr) else "false")

using System;

class GfG {
    static bool isHeapUtil(int[] arr, int i, int n) {
        
        // If leaf node
        if (i >= n / 2)
            return true;

        int left = 2 * i + 1;
        int right = 2 * i + 2;

        // Check left child
        if (arr[i] < arr[left])
            return false;

        // Check right child only if exists
        if (right < n && arr[i] < arr[right])
            return false;

        // Recurse
        return isHeapUtil(arr, left, n) &&
               (right >= n || isHeapUtil(arr, right, n));
    }

    static bool isMaxHeap(int[] arr) {
        return isHeapUtil(arr, 0, arr.Length);
    }

    public static void Main() {
        int[] arr = { 90, 15, 10, 7, 12, 2, 7, 3 };
        Console.WriteLine(isMaxHeap(arr) ? "true" : "false");
    }
}

function isHeapUtil(arr, i, n) {
    
    // If leaf node
    if (i >= Math.floor(n / 2))
        return true;

    let left = 2 * i + 1;
    let right = 2 * i + 2;

    // Check left child
    if (arr[i] < arr[left])
        return false;

    // Check right child only if exists
    if (right < n && arr[i] < arr[right])
        return false;

    // Recurse
    return isHeapUtil(arr, left, n) &&
           (right >= n || isHeapUtil(arr, right, n));
}

function isMaxHeap(arr) {
    return isHeapUtil(arr, 0, arr.length);
}

// Driver code
let arr = [90, 15, 10, 7, 12, 2, 7, 3];
console.log(isMaxHeap(arr) ? 'true' : 'false');

true

[Expected Approach] Iterative - O(n) Time and O(1) Space.

This is mainly an iterative version of the above recursive implementation. We traverse from 0 to index i ≤ (n − 2 ) / 2 because nodes beyond this point are leaf nodes and do not have any children. Indexes of children nodes of index i are 2 ∗ i + 1 and 2 ∗ i + 2

Algorithm:

• Traverse all internal nodes (i = 0 to (n−2)/2) and check if each parent is ≥ its left (2 * i + 1) and right child (2 * i+ 2).
• If any child is greater than its parent return false; otherwise, after full traversal, return true (valid max-heap).
  

#include <iostream>
#include <vector>
using namespace std;

bool isMaxHeap(vector<int>& arr)
{
    int n = arr.size();
    
    // Traverse only internal nodes
    for (int i = 0; i <= (n - 2) / 2; i++)
    {
        // Check left child
        if (arr[2 * i + 1] > arr[i])
            return false;

        // Check right child (ensure index is valid)
        if (2 * i + 2 < n && arr[2 * i + 2] > arr[i])
            return false;
    }
    return true;
}

int main()
{
    vector<int> arr = {90, 15, 10, 7, 12, 2, 7, 3};
    isMaxHeap(arr) ? cout << "true" : cout << "false";
    return 0;
}

import java.util.Arrays;

public class Main {
    public static boolean isMaxHeap(int[] arr) {
        int n = arr.length;
        
        // Traverse only internal nodes
        for (int i = 0; i <= (n - 2) / 2; i++) {
            
            // Check left child
            if (arr[2 * i + 1] > arr[i])
                return false;
            
            // Check right child (ensure index is valid)
            if (2 * i + 2 < n && arr[2 * i + 2] > arr[i])
                return false;
        }
        return true;
    }
    
    public static void main(String[] args) {
        
        int[] arr = {90, 15, 10, 7, 12, 2, 7, 3};
        if (isMaxHeap(arr)) System.out.println("true");
        else System.out.println("false");
    }
}

def isMaxHeap(arr):
    n = len(arr)
    
    # Traverse only internal nodes
    for i in range(0, (n - 2) // 2 + 1):
        
        # Check left child
        if arr[2 * i + 1] > arr[i]:
            return False
        
        # Check right child (ensure index is valid)
        if 2 * i + 2 < n and arr[2 * i + 2] > arr[i]:
            return False
    return True

if __name__ == "__main__":
arr = [90, 15, 10, 7, 12, 2, 7, 3]
print('true') if isMaxHeap(arr) else print('false')

using System;
using System.Collections.Generic;

class GfG {
    static bool isMaxHeap(int[] arr) {
        int n = arr.Length;
        
        // Traverse only internal nodes
        for (int i = 0; i <= (n - 2) / 2; i++) {
            
            // Check left child
            if (arr[2 * i + 1] > arr[i])
                return false;
            
            // Check right child (ensure index is valid)
            if (2 * i + 2 < n && arr[2 * i + 2] > arr[i])
                return false;
        }
        return true;
    }
    
    public static void Main() {
        int[] arr = {90, 15, 10, 7, 12, 2, 7, 3};
        Console.WriteLine(isMaxHeap(arr)? "true" : "false");
    }
}

function isMaxHeap(arr) {
    let n = arr.length;
    
    // Traverse only internal nodes
    for (let i = 0; i <= Math.floor((n - 2) / 2); i++) {
        
        // Check left child
        if (arr[2 * i + 1] > arr[i])
            return false;
        
        // Check right child (ensure index is valid)
        if (2 * i + 2 < n && arr[2 * i + 2] > arr[i])
            return false;
    }
    return true;
}

let arr = [90, 15, 10, 7, 12, 2, 7, 3];
console.log(isMaxHeap(arr) ? 'true' : 'false');

true