Check if a given Binary Tree is a Heap

Given the root of a binary tree, determine whether the tree satisfies the heap property.

Binary tree needs to fulfill the following two conditions for being a heap:

It should be a complete tree (i.e. Every level of the tree, except possibly the last, is completely filled, and all nodes are as far left as possible.).
Every node’s value should be greater than or equal to its child node (considering max-heap).

Examples:

Input:

Output: true
Explanation : The binary tree is a complete binary tree, and every node’s value is greater than or equal to its children’s values. Therefore, all heap properties are satisfied, and the tree is a valid max-heap.
Input:

Output: false
Explanation: Max heap property fails as child node with value 4 is greater than parent node with value 3.

Try It Yourself

Table of Content

[Approach 1] Using Recursion - O(n) Time and O(h) Space
[Approach 2] Single-Pass Recursive Heap Check - O(n) Time and O(h) Space
[Approach 3] Using Level Order Traversal - O(n) Time and O(n) Space

[Approach 1] Using Recursion - O(n) Time and O(h) Space

To check if a binary tree is a max-heap, we need to verify two conditions. First, the tree must be a complete binary tree, This is checked recursively by assigning an index to each node and ensuring no node exceeds the total count. Second, the tree must satisfy the heap property, where every parent node has a value greater than or equal to its children. Using recursion, we compare each node with its children and continue the check for all subtrees. If both conditions hold, the tree is a valid max-heap.

C++

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

// Node Structure
class Node
{
  public:
    int key;
    Node *left;
    Node *right;

    Node(int k)
    {
        key = k;
        left = nullptr;
        right = nullptr;
    }
};

// This function counts the
// number of nodes in a binary tree
int countNodes(Node *root)
{
    if (root == nullptr)
        return 0;
    return 1 + countNodes(root->left) + countNodes(root->right);
}

// This function checks if the
// binary tree is complete or not
bool isCompleteUtil(Node *root, int index, int numberOfNodes)
{
    if (root == nullptr)
        return true;

    // If index assigned to current node is more than
    // number of nodes in the tree,
    // then the tree is not complete
    if (index >= numberOfNodes)
        return false;

    // Recur for left and right subtrees
    return isCompleteUtil(root->left, 2 * index + 1, numberOfNodes) &&
           isCompleteUtil(root->right, 2 * index + 2, numberOfNodes);
}

// This function checks the heap property in the tree.
bool isHeapUtil(Node *root)
{
    if (root->left == nullptr && root->right == nullptr)
        return true;

    // Node will be in the second-last level
    if (root->right == nullptr)
    {

        // Check heap property at the node
        // No recursive call because no need to
        // check the last level
        return root->key >= root->left->key;
    }
    else
    {

        // Check heap property at the node and recursively
        if (root->key >= root->left->key && root->key >= root->right->key)
            return isHeapUtil(root->left) && isHeapUtil(root->right);
        else
            return false;
    }
}

// Function to check if the binary tree is
// a Heap or not.
bool isHeap(Node *root)
{

    int nodeCount = countNodes(root);
    int index = 0;

    if (isCompleteUtil(root, index, nodeCount) && isHeapUtil(root))
        return true;
    return false;
}

int main()
{

    // Construct the Binary Tree
    //        97
    //       /  \
    //      46    37
    //     / \   / \
    //    12  3 7   31
    //   /  \
    //  6    9
    Node *root = new Node(97);
    root->left = new Node(46);
    root->right = new Node(37);
    root->left->left = new Node(12);
    root->left->right = new Node(3);
    root->right->left = new Node(7);
    root->right->right = new Node(31);
    root->left->left->left = new Node(6);
    root->left->left->right = new Node(9);

    if (isHeap(root))
    {
        cout << "true";
    }
    else
        cout << "false";

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// Node Structure
struct Node
{
    int key;
    struct Node *left;
    struct Node *right;
};

// Function to create a new Node
struct Node* Node_new(int k)
{
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->key = k;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// This function counts the
// number of nodes in a binary tree
int countNodes(struct Node *root)
{
    if (root == NULL)
        return 0;
    return 1 + countNodes(root->left) + countNodes(root->right);
}

// This function checks if the
// binary tree is complete or not
int isCompleteUtil(struct Node *root, int index, int numberOfNodes)
{
    if (root == NULL)
        return 1;

    // If index assigned to current node is more than
    // number of nodes in the tree,
    // then the tree is not complete
    if (index >= numberOfNodes)
        return 0;

    // Recur for left and right subtrees
    return isCompleteUtil(root->left, 2 * index + 1, numberOfNodes) &&
           isCompleteUtil(root->right, 2 * index + 2, numberOfNodes);
}

// This function checks the heap property in the tree.
int isHeapUtil(struct Node *root)
{
    if (root->left == NULL && root->right == NULL)
        return 1;

    // Node will be in the second-last level
    if (root->right == NULL)
    {

        // Check heap property at the node
        // No recursive call because no need to
        // check the last level
        return root->key >= root->left->key;
    }
    else
    {

        // Check heap property at the node and recursively
        if (root->key >= root->left->key && root->key >= root->right->key)
            return isHeapUtil(root->left) && isHeapUtil(root->right);
        else
            return 0;
    }
}

// Function to check if the binary tree is
// a Heap or not.
int isHeap(struct Node *root)
{

    int nodeCount = countNodes(root);
    int index = 0;

    if (isCompleteUtil(root, index, nodeCount) && isHeapUtil(root))
        return 1;
    return 0;
}

int main()
{

    // Construct the Binary Tree
    //        97
    //       /  \
    //      46    37
    //     / \   / \
    //    12  3 7   31
    //   /  \
    //  6    9
    struct Node *root = Node_new(97);
    root->left = Node_new(46);
    root->right = Node_new(37);
    root->left->left = Node_new(12);
    root->left->right = Node_new(3);
    root->right->left = Node_new(7);
    root->right->right = Node_new(31);
    root->left->left->left = Node_new(6);
    root->left->left->right = Node_new(9);

    if (isHeap(root))
    {
        printf("true");
    }
    else
        printf("false");

    return 0;
}

Java

import java.util.LinkedList; 
import java.util.Queue;    

// Node Structure
class Node {
    int key;
    Node left;
    Node right;

    Node(int k) {
        key = k;
        left = null;
        right = null;
    }
}

// This function counts the
// number of nodes in a binary tree 
class GFG {

    static int countNodes(Node root) {
        if (root == null)
            return 0;
        return 1 + countNodes(root.left) + countNodes(root.right);
    }

    // This function checks if the
    // binary tree is complete or not 
    static boolean isCompleteUtil(Node root, int index, int numberOfNodes) {
        if (root == null)
            return true;

        // If index assigned to current node is more than 
        // number of nodes in the tree,
        // then the tree is not complete
        if (index >= numberOfNodes)
            return false;

        // Recur for left and right subtrees
        return isCompleteUtil(root.left, 2 * index + 1, numberOfNodes) &&
               isCompleteUtil(root.right, 2 * index + 2, numberOfNodes);
    }

    // This function checks the heap property in the tree.
    static boolean isHeapUtil(Node root) {
        if (root.left == null && root.right == null)
            return true;

        // Node will be in the second-last level
        if (root.right == null) {

            // Check heap property at the node
            // No recursive call because no need to
            // check the last level
            return root.key >= root.left.key;
        } else {

            // Check heap property at the node and recursively
            if (root.key >= root.left.key && root.key >= root.right.key)
                return isHeapUtil(root.left) && isHeapUtil(root.right);
            else
                return false;
        }
    }

    // Function to check if the binary tree is
    // a Heap or not.
    static boolean isHeap(Node root) {

        int nodeCount = countNodes(root);
        int index = 0;

        if (isCompleteUtil(root, index, nodeCount) && isHeapUtil(root))
            return true;
        return false;
    }

    public static void main(String[] args) {

        // Construct the Binary Tree
        //        97
        //       /  \
        //      46    37
        //     / \   / \
        //    12  3 7   31
        //   /  \
        //  6    9
        Node root = new Node(97);
        root.left = new Node(46);
        root.right = new Node(37);
        root.left.left = new Node(12);
        root.left.right = new Node(3);
        root.right.left = new Node(7);
        root.right.right = new Node(31);
        root.left.left.left = new Node(6);
        root.left.left.right = new Node(9);

        if (isHeap(root)) {
            System.out.println("true");
        } else
            System.out.println("false");
    }
}

Python

# Node Structure
class Node:
    def __init__(self, k):
        self.key = k
        self.left = None
        self.right = None

# This function counts the
# number of nodes in a binary tree
def countNodes(root):
    if root is None:
        return 0
    return 1 + countNodes(root.left) + countNodes(root.right)

# This function checks if the
# binary tree is complete or not
def isCompleteUtil(root, index, numberOfNodes):
    if root is None:
        return True

    # If index assigned to current node is more than
    # number of nodes in the tree,
    # then the tree is not complete
    if index >= numberOfNodes:
        return False

    # Recur for left and right subtrees
    return isCompleteUtil(root.left, 2 * index + 1, numberOfNodes) and \
           isCompleteUtil(root.right, 2 * index + 2, numberOfNodes)

# This function checks the heap property in the tree
def isHeapUtil(root):
    if root.left is None and root.right is None:
        return True

    # Node will be in the second-last level
    if root.right is None:

        # Check heap property at the node
        # No recursive call because no need to
        # check the last level
        return root.key >= root.left.key
    else:

        # Check heap property at the node and recursively
        if root.key >= root.left.key and root.key >= root.right.key:
            return isHeapUtil(root.left) and isHeapUtil(root.right)
        else:
            return False

# Function to check if the binary tree is
# a Heap or not
def isHeap(root):
    nodeCount = countNodes(root)
    index = 0

    if isCompleteUtil(root, index, nodeCount) and isHeapUtil(root):
        return True
    return False

if __name__ == "__main__":
    # Construct the Binary Tree
    #        97
    #       /  \
    #      46    37
    #     / \   / \
    #    12  3 7   31
    #   /  \
    #  6    9
    root = Node(97)
    root.left = Node(46)
    root.right = Node(37)
    root.left.left = Node(12)
    root.left.right = Node(3)
    root.right.left = Node(7)
    root.right.right = Node(31)
    root.left.left.left = Node(6)
    root.left.left.right = Node(9)

    if isHeap(root):
        print("true")
    else:
        print("false")

using System;

// Node Structure
public class Node
{
    public int key;
    public Node left;
    public Node right;

    public Node(int k)
    {
        key = k;
        left = null;
        right = null;
    }
}

public class GFG
{
    // This function counts the
    // number of nodes in a binary tree
    public static int countNodes(Node root)
    {
        if (root == null)
            return 0;
        return 1 + countNodes(root.left) + countNodes(root.right);
    }

    // This function checks if the
    // binary tree is complete or not
    public static bool isCompleteUtil(Node root, int index, int numberOfNodes)
    {
        if (root == null)
            return true;

        // If index assigned to current node is more than
        // number of nodes in the tree,
        // then the tree is not complete
        if (index >= numberOfNodes)
            return false;

        // Recur for left and right subtrees
        return isCompleteUtil(root.left, 2 * index + 1, numberOfNodes) &&
               isCompleteUtil(root.right, 2 * index + 2, numberOfNodes);
    }

    // This function checks the heap property in the tree
    public static bool isHeapUtil(Node root)
    {
        if (root.left == null && root.right == null)
            return true;

        // Node will be in the second-last level
        if (root.right == null)
        {
            // Check heap property at the node
            // No recursive call because no need to
            // check the last level
            return root.key >= root.left.key;
        }
        else
        {
            // Check heap property at the node and recursively
            if (root.key >= root.left.key && root.key >= root.right.key)
                return isHeapUtil(root.left) && isHeapUtil(root.right);
            else
                return false;
        }
    }

    // Function to check if the binary tree is
    // a Heap or not
    public static bool isHeap(Node root)
    {
        int nodeCount = countNodes(root);
        int index = 0;

        if (isCompleteUtil(root, index, nodeCount) && isHeapUtil(root))
            return true;
        return false;
    }

    public static void Main(string[] args)
    {
        // Construct the Binary Tree
        //        97
        //       /  \
        //      46    37
        //     / \   / \
        //    12  3 7   31
        //   /  \
        //  6    9
        Node root = new Node(97);
        root.left = new Node(46);
        root.right = new Node(37);
        root.left.left = new Node(12);
        root.left.right = new Node(3);
        root.right.left = new Node(7);
        root.right.right = new Node(31);
        root.left.left.left = new Node(6);
        root.left.left.right = new Node(9);

        if (isHeap(root))
            Console.WriteLine("true");
        else
            Console.WriteLine("false");
    }
}

JavaScript

// Node Structure
class Node {
    constructor(k) {
        this.key = k;
        this.left = null;
        this.right = null;
    }
}

// This function counts the
// number of nodes in a binary tree
function countNodes(root) {
    if (root === null) return 0;
    return 1 + countNodes(root.left) + countNodes(root.right);
}

// This function checks if the
// binary tree is complete or not
function isCompleteUtil(root, index, numberOfNodes) {
    if (root === null) return true;

    // If index assigned to current node is more than
    // number of nodes in the tree,
    // then the tree is not complete
    if (index >= numberOfNodes) return false;

    // Recur for left and right subtrees
    return isCompleteUtil(root.left, 2 * index + 1, numberOfNodes) &&
           isCompleteUtil(root.right, 2 * index + 2, numberOfNodes);
}

// This function checks the heap property in the tree
function isHeapUtil(root) {
    if (root.left === null && root.right === null) return true;

    // Node will be in the second-last level
    if (root.right === null) {
        
        // Check heap property at the node
        // No recursive call because no need to
        // check the last level
        return root.key >= root.left.key;
    } else {
        
        // Check heap property at the node and recursively
        if (root.key >= root.left.key && root.key >= root.right.key)
            return isHeapUtil(root.left) && isHeapUtil(root.right);
        else
            return false;
    }
}

// Function to check if the binary tree is
// a Heap or not
function isHeap(root) {
    const nodeCount = countNodes(root);
    const index = 0;

    if (isCompleteUtil(root, index, nodeCount) && isHeapUtil(root))
        return true;
    return false;
}
//Driver Code
// Construct the Binary Tree
//        97
//       /  \
//      46    37
//     / \   / \
//    12  3 7   31
//   /  \
//  6    9
const root = new Node(97);
root.left = new Node(46);
root.right = new Node(37);
root.left.left = new Node(12);
root.left.right = new Node(3);
root.right.left = new Node(7);
root.right.right = new Node(31);
root.left.left.left = new Node(6);
root.left.left.right = new Node(9);

if (isHeap(root)) {
    console.log("true");
} else {
    console.log("false");
}

Output

true

[Approach 2] Single-Pass Recursive Heap Check - O(n) Time and O(h) Space

This approach uses a single recursive function to check whether a binary tree is a max-heap. At each node, it ensures the parent’s value is greater than or equal to its children and simultaneously verifies completeness by checking the node’s position in the tree. Leaf nodes automatically satisfy the heap property, while internal nodes recursively validate their left and right subtrees. If all nodes meet these conditions, the tree is a valid max-heap.

C++

#include <iostream>
using namespace std;

// Node Structure
class Node {
public:
    int data;
    Node* left;
    Node* right;
    Node(int val) {
        data = val;
        left = nullptr;
        right = nullptr;
    }
};

// Count total nodes
int countNodes(Node* root) {
    if (!root) return 0;
    return 1 + countNodes(root->left) + countNodes(root->right);
}

//recursion to check completeness and heap
bool isHeap(Node* root, int index, int totalNodes) {
    if (!root) return true;

    // Check completeness
    if (index >= totalNodes) return false;

    // Check heap property
    if ((root->left && root->left->data > root->data) ||
        (root->right && root->right->data > root->data))
        return false;

    // Recur for left and right
    return isHeap(root->left, 2*index+1, totalNodes) &&
           isHeap(root->right, 2*index+2, totalNodes);
}

int main() {
   // Construct the Binary Tree
    //        97
    //       /  \
    //      46    37
    //     / \   / \
    //    12  3 7   31
    //   /  \
    //  6    9
    Node *root = new Node(97);
    root->left = new Node(46);
    root->right = new Node(37);
    root->left->left = new Node(12);
    root->left->right = new Node(3);
    root->right->left = new Node(7);
    root->right->right = new Node(31);
    root->left->left->left = new Node(6);
    root->left->left->right = new Node(9);

    int totalNodes = countNodes(root);
    if (isHeap(root, 0, totalNodes))
        cout << "true" << endl;
    else
        cout << "false" << endl;

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// Node Structure
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

struct Node* Node_create(int val) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->data = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// Count total nodes
int countNodes(struct Node* root) {
    if (!root) return 0;
    return 1 + countNodes(root->left) + countNodes(root->right);
}

// recursion to check completeness and heap
int isHeap(struct Node* root, int index, int totalNodes) {
    if (!root) return 1;

    // Check completeness
    if (index >= totalNodes) return 0;

    // Check heap property
    if ((root->left && root->left->data > root->data) ||
        (root->right && root->right->data > root->data))
        return 0;

    // Recur for left and right
    return isHeap(root->left, 2*index+1, totalNodes) &&
           isHeap(root->right, 2*index+2, totalNodes);
}

int main() {
    // Construct the Binary Tree
    //        97
    //       /  \
    //      46    37
    //     / \   / \
    //    12  3 7   31
    //   /  \
    //  6    9
    struct Node* root = Node_create(97);
    root->left = Node_create(46);
    root->right = Node_create(37);
    root->left->left = Node_create(12);
    root->left->right = Node_create(3);
    root->right->left = Node_create(7);
    root->right->right = Node_create(31);
    root->left->left->left = Node_create(6);
    root->left->left->right = Node_create(9);

    int totalNodes = countNodes(root);
    if (isHeap(root, 0, totalNodes))
        printf("true\n");
    else
        printf("false\n");

    return 0;
}

Java

// Node Structure
class Node {
    int data;
    Node left;
    Node right;

    Node(int val) {
        data = val;
        left = null;
        right = null;
    }
}

public class GFG {

    // Count total nodes
    static int countNodes(Node root) {
        if (root == null) return 0;
        return 1 + countNodes(root.left) + countNodes(root.right);
    }

    // recursion to check completeness and heap
    static boolean isHeap(Node root, int index, int totalNodes) {
        if (root == null) return true;

        // Check completeness
        if (index >= totalNodes) return false;

        // Check heap property
        if ((root.left != null && root.left.data > root.data) ||
            (root.right != null && root.right.data > root.data))
            return false;

        // Recur for left and right
        return isHeap(root.left, 2*index+1, totalNodes) &&
               isHeap(root.right, 2*index+2, totalNodes);
    }

    public static void main(String[] args) {
        // Construct the Binary Tree
        //        97
        //       /  \
        //      46    37
        //     / \   / \
        //    12  3 7   31
        //   /  \
        //  6    9
        Node root = new Node(97);
        root.left = new Node(46);
        root.right = new Node(37);
        root.left.left = new Node(12);
        root.left.right = new Node(3);
        root.right.left = new Node(7);
        root.right.right = new Node(31);
        root.left.left.left = new Node(6);
        root.left.left.right = new Node(9);

        int totalNodes = countNodes(root);
        if (isHeap(root, 0, totalNodes))
            System.out.println("true");
        else
            System.out.println("false");
    }
}

Python

# Node Structure
class Node:
    def __init__(self, val):
        self.data = val
        self.left = None
        self.right = None

# Count total nodes
def countNodes(root):
    if root is None:
        return 0
    return 1 + countNodes(root.left) + countNodes(root.right)

# recursion to check completeness and heap
def isHeap(root, index, totalNodes):
    if root is None:
        return True

    # Check completeness
    if index >= totalNodes:
        return False

    # Check heap property
    if (root.left and root.left.data > root.data) or \
       (root.right and root.right.data > root.data):
        return False

    # Recur for left and right
    return isHeap(root.left, 2*index + 1, totalNodes) and \
           isHeap(root.right, 2*index + 2, totalNodes)

if __name__ == "__main__":
    # Construct the Binary Tree
    #        97
    #       /  \
    #      46    37
    #     / \   / \
    #    12  3 7   31
    #   /  \
    #  6    9
    root = Node(97)
    root.left = Node(46)
    root.right = Node(37)
    root.left.left = Node(12)
    root.left.right = Node(3)
    root.right.left = Node(7)
    root.right.right = Node(31)
    root.left.left.left = Node(6)
    root.left.left.right = Node(9)

    totalNodes = countNodes(root)
    if isHeap(root, 0, totalNodes):
        print("true")
    else:
        print("false")

using System;

// Node Structure
class Node
{
    public int data;
    public Node left;
    public Node right;

    public Node(int val)
    {
        data = val;
        left = null;
        right = null;
    }
}

class GFG
{
    // Count total nodes
    public static int countNodes(Node root)
    {
        if (root == null)
            return 0;
        return 1 + countNodes(root.left) + countNodes(root.right);
    }

    // recursion to check completeness and heap
    public static bool isHeap(Node root, int index, int totalNodes)
    {
        if (root == null)
            return true;

        // Check completeness
        if (index >= totalNodes)
            return false;

        // Check heap property
        if ((root.left != null && root.left.data > root.data) ||
            (root.right != null && root.right.data > root.data))
            return false;

        // Recur for left and right
        return isHeap(root.left, 2 * index + 1, totalNodes) &&
               isHeap(root.right, 2 * index + 2, totalNodes);
    }

    static void Main(string[] args)
    {
        // Construct the Binary Tree
        //        97
        //       /  \
        //      46    37
        //     / \   / \
        //    12  3 7   31
        //   /  \
        //  6    9
        Node root = new Node(97);
        root.left = new Node(46);
        root.right = new Node(37);
        root.left.left = new Node(12);
        root.left.right = new Node(3);
        root.right.left = new Node(7);
        root.right.right = new Node(31);
        root.left.left.left = new Node(6);
        root.left.left.right = new Node(9);

        int totalNodes = countNodes(root);
        if (isHeap(root, 0, totalNodes))
            Console.WriteLine("true");
        else
            Console.WriteLine("false");
    }
}

JavaScript

// Node Structure
class Node {
    constructor(val) {
        this.data = val;
        this.left = null;
        this.right = null;
    }
}

// Count total nodes
function countNodes(root) {
    if (root === null) return 0;
    return 1 + countNodes(root.left) + countNodes(root.right);
}

// recursion to check completeness and heap
function isHeap(root, index, totalNodes) {
    if (root === null) return true;

    // Check completeness
    if (index >= totalNodes) return false;

    // Check heap property
    if ((root.left && root.left.data > root.data) ||
        (root.right && root.right.data > root.data)) {
        return false;
    }

    // Recur for left and right
    return isHeap(root.left, 2 * index + 1, totalNodes) &&
           isHeap(root.right, 2 * index + 2, totalNodes);
}
//Driver Code
// Construct the Binary Tree
//        97
//       /  \
//      46    37
//     / \   / \
//    12  3 7   31
//   /  \
//  6    9
let root = new Node(97);
root.left = new Node(46);
root.right = new Node(37);
root.left.left = new Node(12);
root.left.right = new Node(3);
root.right.left = new Node(7);
root.right.right = new Node(31);
root.left.left.left = new Node(6);
root.left.left.right = new Node(9);

let totalNodes = countNodes(root);
if (isHeap(root, 0, totalNodes))
    console.log("true");
else
    console.log("false");

Output

true

[Approach 3] Using Level Order Traversal - O(n) Time and O(n) Space

The idea is to use level order traversal to verify heap properties. Traverse the tree level by level, checking that each node’s value is greater than its children. To keep track of completeness, use a boolean flag variable that becomes true when a node with missing children is encountered; after this point, no node should have any children. If any node violates the heap property or completeness rule, return false. If the entire traversal satisfies both conditions, the tree is a valid max-heap.

C++

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

// Node Structure
class Node {
public:
    int data;
    Node* left;
    Node* right;

    Node(int k) {
        data = k;
        left = nullptr;
        right = nullptr;
    }
};

bool isHeap(Node* root) {
    queue<Node*> q;     
    q.push(root);
     // Flag indicates if a node
     //with missing children has been seen
    bool flag = false;   
  
    while (!q.empty()) {
        Node* temp = q.front();
        q.pop();

        // Check left child
        if (temp->left) {
            // If a node with missing child was seen before 
            // or if left child is bigger than parent, the heap rules are broken
            if (flag || temp->left->data > temp->data) {
                return false;
            }
            q.push(temp->left);
        } 
        else {
            // Left child is missing; set
            //flag indicating last node encountered
            flag = true;
        }
      
        // Check right child
        if (temp->right) {
            // Same checks as left child
            if (flag || temp->right->data > temp->data) {
                return false;
            }
            q.push(temp->right);
        }
        else {
            // Right child is missing; set flag
            flag = true;
        }
    }
    return true; 
}

int main() {
    // Construct the Binary Tree
    //        97
    //       /  \
    //      46    37
    //     / \   / \
    //    12  3 7   31
    //   /  \
    //  6    9
    Node *root = new Node(97);
    root->left = new Node(46);
    root->right = new Node(37);
    root->left->left = new Node(12);
    root->left->right = new Node(3);
    root->right->left = new Node(7);
    root->right->right = new Node(31);
    root->left->left->left = new Node(6);
    root->left->left->right = new Node(9);

    if(isHeap(root)){
        cout << "true" << endl;
    }
    else {
        cout << "false" << endl;
    }

    return 0;
}

Java

import java.util.Queue;
import java.util.LinkedList;

// Node Structure
class Node {
    int data;
    Node left;
    Node right;

    Node(int k) {
        data = k;
        left = null;
        right = null;
    }
}

public class GFG {

    public static boolean isHeap(Node root) {
        Queue<Node> q = new LinkedList<>();
        q.add(root);
         // Flag indicates if a node
         //with missing children has been seen
        boolean flag = false;   

        while (!q.isEmpty()) {
            Node temp = q.poll();

            // Check left child
            if (temp.left != null) {
                // If a node with missing child was seen before 
                // or if left child is bigger than parent, the heap rules are broken
                if (flag || temp.left.data > temp.data) {
                    return false;
                }
                q.add(temp.left);
            } 
            else {
                // Left child is missing; set
                //flag indicating last node encountered
                flag = true;
            }

            // Check right child
            if (temp.right != null) {
                // Same checks as left child
                if (flag || temp.right.data > temp.data) {
                    return false;
                }
                q.add(temp.right);
            }
            else {
                // Right child is missing; set flag
                flag = true;
            }
        }
        return true; 
    }

    public static void main(String[] args) {
        // Construct the Binary Tree
        //        97
        //       /  \
        //      46    37
        //     / \   / \
        //    12  3 7   31
        //   /  \
        //  6    9
        Node root = new Node(97);
        root.left = new Node(46);
        root.right = new Node(37);
        root.left.left = new Node(12);
        root.left.right = new Node(3);
        root.right.left = new Node(7);
        root.right.right = new Node(31);
        root.left.left.left = new Node(6);
        root.left.left.right = new Node(9);

        if(isHeap(root)){
            System.out.println("true");
        }
        else {
            System.out.println("false");
        }
    }
}

Python

from collections import deque

# Node Structure
class Node:
    def __init__(self, k):
        self.data = k
        self.left = None
        self.right = None

def isHeap(root):
    q = deque()
    q.append(root)
     # Flag indicates if a node
     #with missing children has been seen
    flag = False

    while q:
        temp = q.popleft()

        # Check left child
        if temp.left:
            # If a node with missing child was seen before 
            # or if left child is bigger than parent, the heap rules are broken
            if flag or temp.left.data > temp.data:
                return False
            q.append(temp.left)
        else:
            # Left child is missing; set
            #flag indicating last node encountered
            flag = True

        # Check right child
        if temp.right:
            # Same checks as left child
            if flag or temp.right.data > temp.data:
                return False
            q.append(temp.right)
        else:
            # Right child is missing; set flag
            flag = True

    return True

if __name__ == "__main__":
    # Construct the Binary Tree
    #        97
    #       /  \
    #      46    37
    #     / \   / \
    #    12  3 7   31
    #   /  \
    #  6    9
    root = Node(97)
    root.left = Node(46)
    root.right = Node(37)
    root.left.left = Node(12)
    root.left.right = Node(3)
    root.right.left = Node(7)
    root.right.right = Node(31)
    root.left.left.left = Node(6)
    root.left.left.right = Node(9)

    if isHeap(root):
        print("true")
    else:
        print("false")

using System;
using System.Collections.Generic;

// Node Structure
class Node {
    public int data;
    public Node left;
    public Node right;

    public Node(int k) {
        data = k;
        left = null;
        right = null;
    }
}

class GFG {

    static bool isHeap(Node root) {
        Queue<Node> q = new Queue<Node>();
        q.Enqueue(root);
         // Flag indicates if a node
         //with missing children has been seen
        bool flag = false;

        while (q.Count > 0) {
            Node temp = q.Dequeue();

            // Check left child
            if (temp.left != null) {
                // If a node with missing child was seen before 
                // or if left child is bigger than parent, the heap rules are broken
                if (flag || temp.left.data > temp.data) {
                    return false;
                }
                q.Enqueue(temp.left);
            } 
            else {
                // Left child is missing; set
                //flag indicating last node encountered
                flag = true;
            }

            // Check right child
            if (temp.right != null) {
                // Same checks as left child
                if (flag || temp.right.data > temp.data) {
                    return false;
                }
                q.Enqueue(temp.right);
            }
            else {
                // Right child is missing; set flag
                flag = true;
            }
        }
        return true;
    }

    static void Main(string[] args) {
        
        // Construct the Binary Tree
        //        97
        //       /  \
        //      46    37
        //     / \   / \
        //    12  3 7   31
        //   /  \
        //  6    9
        Node root = new Node(97);
        root.left = new Node(46);
        root.right = new Node(37);
        root.left.left = new Node(12);
        root.left.right = new Node(3);
        root.right.left = new Node(7);
        root.right.right = new Node(31);
        root.left.left.left = new Node(6);
        root.left.left.right = new Node(9);

        if(isHeap(root)){
            Console.WriteLine("true");
        }
        else {
            Console.WriteLine("false");
        }
    }
}

JavaScript

// Node Structure
class Node {
    constructor(k) {
        this.data = k;
        this.left = null;
        this.right = null;
    }
}

// Custom Queue Implementation
class Queue {
    constructor() {
        this.items = [];
        this.frontIndex = 0;
    }

    enqueue(element) {
        this.items.push(element);
    }

    dequeue() {
        if (this.isEmpty()) return null;
        return this.items[this.frontIndex++];
    }

    isEmpty() {
        return this.frontIndex >= this.items.length;
    }
}

function isHeap(root) {
    let q = new Queue();
    q.enqueue(root);
    
    // Flag indicates if a node
    // with missing children has been seen
    let flag = false;

    while (!q.isEmpty()) {
        let temp = q.dequeue();

        // Check left child
        if (temp.left) {
            
            // If a node with missing child was seen before 
            // or if left child is bigger than parent, the heap rules are broken
            if (flag || temp.left.data > temp.data) {
                return false;
            }
            q.enqueue(temp.left);
        } 
        else {
            
            // Left child is missing; set
            // flag indicating last node encountered
            flag = true;
        }

        // Check right child
        if (temp.right) {
            // Same checks as left child
            if (flag || temp.right.data > temp.data) {
                return false;
            }
            q.enqueue(temp.right);
        }
        else {
            // Right child is missing; set flag
            flag = true;
        }
    }
    return true;
}

// Driver Code
// Construct the Binary Tree
//        97
//       /  \
//      46    37
//     / \   / \
//    12  3 7   31
//   /  \
//  6    9
let root = new Node(97);
root.left = new Node(46);
root.right = new Node(37);
root.left.left = new Node(12);
root.left.right = new Node(3);
root.right.left = new Node(7);
root.right.right = new Node(31);
root.left.left.left = new Node(6);
root.left.left.right = new Node(9);

if (isHeap(root)) {
    console.log("true");
} else {
    console.log("false");
}

Output

true

Check if a given Binary Tree is a Heap

[Approach 1] Using Recursion - O(n) Time and O(h) Space

[Approach 2] Single-Pass Recursive Heap Check - O(n) Time and O(h) Space

[Approach 3] Using Level Order Traversal - O(n) Time and O(n) Space

Explore