给定二叉树的层序遍历，检查树是否是最小堆

给定完全二叉树的层序遍历，判断二叉树是否是有效的最小堆
例子：

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

我们需要检查每个非叶子节点（父节点）是否满足堆属性。为此，我们检查每个父节点（在索引 i 处）是否小于其子节点（在索引 2*i+1 和 2*i+2 处，如果父节点有两个子节点）。如果只有一个孩子，我们只根据索引 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[0]);
    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

输出：

True

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。