1147 Heaps（30 分）（C++）

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

给定一个完全二叉树的层次遍历，判断该树是否为大顶堆或者小顶堆，同时写出该完全二叉树的后序排列

分为两步：

1、由完全二叉树的层次遍历得出其后序遍历

2、判断大顶堆还是小顶堆

步骤一：直接用后序遍历即可解决

步骤二：首先初步判断，直接用层次遍历的第一个节点与最后一个节点初步判断可能是大顶堆，还是小顶堆。其次判断是否是堆用的是先序遍历，且只需要判断非叶子节点（m/2）。

#include <iostream>
#include <vector>
using namespace std;
int n, m, cnt, flag;
std::vector<int> level(1005, -1);
void isheap(int index){
    if(flag == -1 || index > m / 2)
        return;
    if(flag == 1){
        if(level[2 * index] > level[index] || (2 * index + 1 <= m  && level[2 * index + 1] > level[index])){
            flag = -1;
            return;
        }
    }
    else{
        if(level[2 * index] < level[index] || (2 * index + 1 <= m  && level[2 * index + 1] < level[index])){
            flag = -1;
            return;
        }
    }
    isheap(2 * index);
    isheap(2 * index + 1);
}
void posttravel(int index){
    if(index > m)
        return;
    posttravel(2 * index);
    posttravel(2 * index + 1);
    if(cnt ++ != 0)
        printf(" ");
    printf("%d", level[index]);
}
int main(){
    cin >> n >> m;
    for(int i = 0; i < n; ++ i){
        for(int j = 1; j <= m; ++ j)
            scanf("%d",&level[j]);
        flag = level[1] > level[m] ? 1 : 2;
        isheap(1);
        printf("%s\n",flag == -1 ? "Not Heap" : flag == 1 ? "Max Heap" : "Min Heap");
        cnt = 0;
        posttravel(1);
        printf("\n");
    }
}

优化一下，将两个遍历结合为一个遍历(＾－＾)V。

即在后序遍历的同时，在遍历叶子节点前判断一下是否满足堆。

#include <iostream>
#include <vector>
using namespace std;
int n, m, flag;
vector<int>post, level;
void dfs(int index){
	if(index > n)
		return;
	if(flag == 1 && ((2 * index <= n && level[2 * index] > level[index]) || (2 * index + 1 <= n && level[2 * index + 1] > level[index])))
		flag = -1;
	else if(flag == 2 && ((2 * index <= n && level[2 * index] < level[index]) || (2 * index + 1 <= n && level[2 * index + 1] < level[index])))
		flag = -1;
	dfs(2 * index);
	dfs(2 * index + 1);
	post.push_back(level[index]);
}
int main(){
	scanf("%d %d", &m, &n);
	for(int i = 0; i < m; ++ i){
		level.resize(n + 1);
		post.clear();
		for(int j = 1; j <= n; ++ j)
			scanf("%d", &level[j]);
		flag = level[1] > level[n] ? 1 : 2;
		dfs(1);
		printf("%s\n%d", flag == -1 ? "Not Heap" : flag == 1 ? "Max Heap" : "Min Heap", post[0]);
		for(int j = 1; j < n; ++ j)
			printf(" %d", post[j]);
		printf("\n");
	}
}