1147 Heaps （30 分）

1147 Heaps （30 分）

In computer science, a heap is a specialized tree-based data structure that satisfies the heap property: if P is a parent node of C, then the key (the value) of P is either greater than or equal to (in a max heap) or less than or equal to (in a min heap) the key of C. A common implementation of a heap is the binary heap, in which the tree is a complete binary tree. (Quoted from Wikipedia at https://en.wikipedia.org/wiki/Heap_(data_structure))

Your job is to tell if a given complete binary tree is a heap.

Input Specification:

Each input file contains one test case. For each case, the first line gives two positive integers: M (≤ 100), the number of trees to be tested; and N (1 < N ≤ 1,000), the number of keys in each tree, respectively. Then M lines follow, each contains N distinct integer keys (all in the range of int), which gives the level order traversal sequence of a complete binary tree.

Output Specification:

For each given tree, print in a line Max Heap if it is a max heap, or Min Heap for a min heap, or Not Heap if it is not a heap at all. Then in the next line print the tree's postorder traversal sequence. All the numbers are separated by a space, and there must no extra space at the beginning or the end of the line.

Sample Input:

3 8
98 72 86 60 65 12 23 50
8 38 25 58 52 82 70 60
10 28 15 12 34 9 8 56

Sample Output:

Max Heap
50 60 65 72 12 23 86 98
Min Heap
60 58 52 38 82 70 25 8
Not Heap
56 12 34 28 9 8 15 10

//题意：给你m组测试,每组n个数，由这n个数组成一棵完全二叉树，要求你判断，这棵树是大顶堆还是小顶堆，或者都不是。 

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
int a[1110];
int n,m;
struct Node
{
    int data;
    Node *l;
    Node *r;
    Node()
    {
        l=NULL;
        r=NULL;
    }
};
Node *buildTree(Node *root,int k)
{
    queue<Node*>q;
    q.push(root);
    int cn=1;
    while(!q.empty())
    {
        Node *temp=q.front();
        q.pop();
        temp->data=a[k++];
        if(cn+1<=m)
        {
            temp->l=new Node;
            q.push(temp->l);
            cn++;
        }
        if(cn+1<=m)
        {
            temp->r=new Node;
            q.push(temp->r);
            cn++;
        }
    }
    return root;
}
int flag1,flag2,flag;
void check(Node *root)
{
    int flag1,flag2,flag;
    if(root->l!=NULL)
    {
        if(root->data>=root->l->data)flag1=1;
        else flag1=2;
    }else if(root->r!=NULL)
    {
        if(root->data>=root->r->data)flag1=1;
        else flag1=2;
    }
    queue<Node*>q;
    while(!q.empty())q.pop();
    q.push(root);
    while(!q.empty())
    {
        Node *temp=q.front();
        q.pop();
        if(temp->l!=NULL)
        {
            if(temp->data>=temp->l->data)flag2=1;
            else flag2=2;
            if(flag1!=flag2)
            {
                flag=0;
                break;
            }else
            {
                flag=1;
                q.push(temp->l);
            }
        }
        if(temp->r!=NULL)
        {
            if(temp->data>=temp->r->data)flag2=1;
            else flag2=2;
            if(flag1!=flag2)
            {
                flag=0;
                break;
            }else
            {
                flag=1;
                q.push(temp->r);
            }
        }
    }
    if(flag==1)
    {
        if(flag1==1)printf("Max Heap\n");
        else printf("Min Heap\n");
    }else printf("Not Heap\n");
}
vector<int>ans;
void postorder(Node *root)
{
    if(root==NULL)return;
    postorder(root->l);
    postorder(root->r);
    ans.push_back(root->data);
    return;
}
int main()
{

    scanf("%d%d",&n,&m);
    while(n--)
    {

        for(int i=0;i<m;i++)scanf("%d",&a[i]);

        Node *root=new Node;
        root=buildTree(root,0);

        check(root);

        ans.clear();
        postorder(root);
        for(int i=0;i<ans.size();i++)
        {
            printf("%d",ans[i]);
            if(i==ans.size()-1)printf("\n");
            else printf(" ");
        }
    }
    return 0;

}