 GFG App
Open App Browser
Continue

# Given level order traversal of a Binary Tree, check if the Tree is a Min-Heap

Given the level order traversal of a Complete Binary Tree, determine whether the Binary Tree is a valid Min-Heap

Examples:

```Input : level = [10, 15, 14, 25, 30]
Output : True
The tree of the given level order traversal is
10
/  \
15   14
/  \
25   30
We see that each parent has a value less than
its child, and hence satisfies the min-heap
property

Input : level = [30, 56, 22, 49, 30, 51, 2, 67]
Output : False
The tree of the given level order traversal is
30
/      \
56         22
/      \     /   \
49        30  51    2
/
67
We observe that at level 0, 30 > 22, and hence
min-heap property is not satisfied
```

We need to check whether each non-leaf node (parent) satisfies the heap property. For this, we check whether each parent (at index i) is smaller than its children (at indices 2*i+1 and 2*i+2, if the parent has two children). If only one child, we only check the parent against index 2*i+1.

## C++

 `// C++ program to check if a given tree is` `// Binary Heap or not` `#include ` `using` `namespace` `std;`   `// Returns true if given level order traversal` `// is Min Heap.` `bool` `isMinHeap(``int` `level[], ``int` `n)` `{` `    ``// First non leaf node is at index (n/2-1).` `    ``// Check whether each parent is greater than child` `    ``for` `(``int` `i=(n/2-1) ; i>=0 ; i--)` `    ``{` `        ``// Left child will be at index 2*i+1` `        ``// Right child will be at index 2*i+2` `        ``if` `(level[i] > level[2 * i + 1])` `            ``return` `false``;`   `        ``if` `(2*i + 2 < n)` `        ``{` `            ``// If parent is greater than right child` `            ``if` `(level[i] > level[2 * i + 2])` `                ``return` `false``;` `        ``}` `    ``}` `    ``return` `true``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `level[] = {10, 15, 14, 25, 30};` `    ``int` `n = ``sizeof``(level)/``sizeof``(level);` `    ``if`  `(isMinHeap(level, n))` `        ``cout << ``"True"``;` `    ``else` `        ``cout << ``"False"``;` `    ``return` `0;` `}`

## Java

 `// Java program to check if a given tree is` `// Binary Heap or not` `import` `java.io.*;` `import` `java.util.*;`   `public` `class` `detheap` `{` `    ``// Returns true if given level order traversal` `    ``// is Min Heap.` `    ``static` `boolean` `isMinHeap(``int` `[]level)` `    ``{` `        ``int` `n = level.length - ``1``;`   `        ``// First non leaf node is at index (n/2-1).` `        ``// Check whether each parent is greater than child` `        ``for` `(``int` `i=(n/``2``-``1``) ; i>=``0` `; i--)` `        ``{` `            ``// Left child will be at index 2*i+1` `            ``// Right child will be at index 2*i+2` `            ``if` `(level[i] > level[``2` `* i + ``1``])` `                ``return` `false``;`   `            ``if` `(``2``*i + ``2` `< n)` `            ``{` `                ``// If parent is greater than right child` `                ``if` `(level[i] > level[``2` `* i + ``2``])` `                   ``return` `false``;` `            ``}` `        ``}` `        ``return` `true``;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args) ` `                              ``throws` `IOException` `    ``{` `        ``// Level order traversal` `        ``int``[] level = ``new` `int``[]{``10``, ``15``, ``14``, ``25``, ``30``};`   `        ``if`  `(isMinHeap(level))` `            ``System.out.println(``"True"``);` `        ``else` `            ``System.out.println(``"False"``);` `    ``}` `}`

## Python3

 `# Python3 program to check if a given ` `# tree is Binary Heap or not `   `# Returns true if given level order ` `# traversal is Min Heap. ` `def` `isMinHeap(level, n):` `    `  `    ``# First non leaf node is at index ` `    ``# (n/2-1). Check whether each parent` `    ``# is greater than child ` `    ``for` `i ``in` `range``(``int``(n ``/` `2``) ``-` `1``, ``-``1``, ``-``1``):` `        `  `        ``# Left child will be at index 2*i+1 ` `        ``# Right child will be at index 2*i+2 ` `        ``if` `level[i] > level[``2` `*` `i ``+` `1``]: ` `            ``return` `False`   `        ``if` `2` `*` `i ``+` `2` `< n:` `            `  `            ``# If parent is greater than right child ` `            ``if` `level[i] > level[``2` `*` `i ``+` `2``]:` `                ``return` `False` `    ``return` `True`   `# Driver code ` `if` `__name__ ``=``=` `'__main__'``:` `    ``level ``=` `[``10``, ``15``, ``14``, ``25``, ``30``] ` `    ``n ``=` `len``(level)` `    ``if` `isMinHeap(level, n): ` `        ``print``(``"True"``) ` `    ``else``:` `        ``print``(``"False"``)`   `# This code is contributed by PranchalK`

## C#

 `// C# program to check if a given tree ` `// is Binary Heap or not ` `using` `System;`   `class` `GFG` `{` `// Returns true if given level ` `// order traversal is Min Heap. ` `public` `static` `bool` `isMinHeap(``int``[] level)` `{` `    ``int` `n = level.Length - 1;`   `    ``// First non leaf node is at` `    ``// index (n/2-1). Check whether ` `    ``// each parent is greater than child ` `    ``for` `(``int` `i = (n / 2 - 1) ; i >= 0 ; i--)` `    ``{` `        ``// Left child will be at index 2*i+1 ` `        ``// Right child will be at index 2*i+2 ` `        ``if` `(level[i] > level[2 * i + 1])` `        ``{` `            ``return` `false``;` `        ``}`   `        ``if` `(2 * i + 2 < n)` `        ``{` `            ``// If parent is greater than right child ` `            ``if` `(level[i] > level[2 * i + 2])` `            ``{` `            ``return` `false``;` `            ``}` `        ``}` `    ``}` `    ``return` `true``;` `}`   `// Driver code ` `public` `static` `void` `Main(``string``[] args)` `{` `    ``// Level order traversal ` `    ``int``[] level = ``new` `int``[]{10, 15, 14, 25, 30};`   `    ``if` `(isMinHeap(level))` `    ``{` `        ``Console.WriteLine(``"True"``);` `    ``}` `    ``else` `    ``{` `        ``Console.WriteLine(``"False"``);` `    ``}` `}` `}`   `// This code is contributed by Shrikant13`

## PHP

 `= 0; ``\$i``--)` `    ``{` `        ``// Left child will be at index 2*i+1` `        ``// Right child will be at index 2*i+2` `        ``if` `(``\$level``[``\$i``] > ``\$level``[2 * ``\$i` `+ 1])` `            ``return` `false;`   `        ``if` `(2 * ``\$i` `+ 2 < ``\$n``)` `        ``{` `            ``// If parent is greater than right child` `            ``if` `(``\$level``[``\$i``] > ``\$level``[2 * ``\$i` `+ 2])` `                ``return` `false;` `        ``}` `    ``}` `    ``return` `true;` `}`   `// Driver code` `\$level` `= ``array``(10, 15, 14, 25, 30);` `\$n` `= sizeof(``\$level``);` `if` `(isMinHeap(``\$level``, ``\$n``))` `    ``echo` `"True"``;` `else` `    ``echo` `"False"``;`   `// This code is contributed ` `// by Akanksha Rai`

## Javascript

 ``

Output

`True`

Time Complexity: O(n)
Auxiliary Space: O(1)

This article is contributed by Deepak Srivatsav. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.