PAT 甲级 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

题意：

给一个树的层序遍历，判断它是不是堆，是大顶堆还是小顶堆。输出这个树的后序遍历～

题解：

在输入程序遍历的时候就借用队列建树，同时判断堆的类型，建好树以后递归进行后序遍历输出。

方法暴力过于繁琐，下面有别人家的代码。。。

本题思路虽然容易想，但是建树不太熟练，建树通常有两种方法：数组建树 和 链表建树，参见：建树的两种方法

AC代码：

#include<iostream>
#include<algorithm>
#include<queue>
#include<stack>
using namespace std;
int m,n;
struct node{
    int v;
    node *l,*r;
};
queue<node*>q;
int sum=;
node* newnode(int x){//新建一个节点
    node* newnode = new node;
    newnode->v=x;
    newnode->l=newnode->r=NULL;
    return newnode;
}
void postorder(node *&root){//后序遍历
    if(root->l)    postorder(root->l);
    if(root->r) postorder(root->r);
    sum++;//用于计算是否要加空格
    cout<<root->v;
    if(sum!=n) cout<<" ";
    else cout<<endl;
}
int main(){
    cin>>m>>n;
    int x;
    node *root;
    for(int i=;i<=m;i++){
        int f=;//从小到大为1
        while(!q.empty()) q.pop();
        for(int j=;j<=n;j++){
            cin>>x;
            if(j==){
                root= newnode(x);
                q.push(root);
                continue;
            }
            while(!q.empty()){//层序遍历用队列更方便
                node* a = q.front();
                node* b = newnode(x);
                if(a->l==NULL){
                    a->l=b;
                }else if(a->r==NULL){
                    a->r=b;
                }else{
                    q.pop();//如果队头的节点的左右节点装满了就把它扔了再从队头拿出
                    continue;
                }
                q.push(b);
                if(f== && a->v<x){//判读树的类型
                    f=;//从小到大为1
                }else if(f== && a->v>x){
                    f=;//从大到小为2
                }else if(f== && a->v>x){
                    f=-;//不符合条件为-1
                }else if(f== && a->v<x){
                    f=-;
                }
                break;//记得要跳出
            }
        }
        sum=;
        if(f==){
            cout<<"Min Heap"<<endl;
        }else if(f==){
            cout<<"Max Heap"<<endl;
        }else cout<<"Not Heap"<<endl;
        postorder(root);
    }
    return ;
} 

更简单的不用建树的方法:

柳诺大神的做法

首先根据v[0]和v[1]的大小比较判断可能是大顶还是小顶，分别赋值flag为1和-1，先根据层序遍历，从0到n/2-1【所有有孩子的结点】判断他们的孩子是不是满足flag的要求，如果有一个结点不满足，那就将flag=0表示这不是一个堆。根据flag输出是否是堆，大顶堆还是小顶堆，然后后序遍历，根据index分别遍历index*2+1和index*2+2，即他们的左右孩子，遍历完左右子树后输出根结点，即完成了后序遍历～

#include <iostream>
#include <vector>
using namespace std;
int m, n;
vector<int> v;
void postOrder(int index) {
    if (index >= n) return;
    postOrder(index *  + );
    postOrder(index *  + );
    printf("%d%s", v[index], index ==  ? "\n" : " ");
}
int main() {
    scanf("%d%d", &m, &n);
    v.resize(n);
    for (int i = ; i < m; i++) {
        for (int j = ; j < n; j++) scanf("%d", &v[j]);
        int flag = v[] > v[] ?  : -;
        for (int j = ; j < n / ; j++) {
            int left = j *  + , right = j *  + ;
            if (flag ==  && (v[j] < v[left] || (right < n && v[j] < v[right]))) flag = ;
            if (flag == - && (v[j] > v[left] || (right < n && v[j] > v[right]))) flag = ;
        }
        if (flag == ) printf("Not Heap\n");
        else printf("%s Heap\n", flag ==  ? "Max" : "Min");
        postOrder();
    }
    return ;
}