PAT Advanced 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 <= 1000), 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 trees 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. 利用完全二叉树层序序列，递归进行后序序列输出

Code

Code 01

#include <iostream>
#include <vector>
using namespace std;
vector<int> nds;
int n;
bool isMaxHeap(int index) {
	int left = 2*index+1;
	int right = 2*index+2;
	if(left>=n&&right>=n)return true; //叶子节点，返回true 
	if(left<n&&nds[left]>nds[index])return false; //左子节点大于当前节点 
	if(right<n&&nds[right]>nds[index])return false; //右子节点大于当前节点
	return isMaxHeap(left)&&isMaxHeap(right);
}
bool isMinHeap(int index) {
	int left = 2*index+1;
	int right = 2*index+2;
	if(left>=n&&right>=n)return true; //叶子节点，返回true 
	if(left<n&&nds[left]<nds[index])return false; //左子节点小于当前节点 
	if(right<n&&nds[right]<nds[index])return false; //右子节点小于当前节点
	return isMinHeap(left)&&isMinHeap(right);
}
void post(int index){
	if(index>=n)return;
	post(index*2+1);
	post(index*2+2);
	printf("%d%s",nds[index],index==0?"
":" ");//后序遍历，根最后输出 
}
int main(int argc,char * argv[]) {
	int m;
	scanf("%d %d",&m,&n);
	for(int i=0; i<m; i++) {
		nds.clear();
		nds.resize(n);
		for(int j=0; j<n; j++) {
			scanf("%d", &nds[j]);
		}
		if(isMaxHeap(0)) {
			printf("Max Heap
");
		} else if(isMinHeap(0)) {
			printf("Min Heap
");
		} else {
			printf("Not Heap
");
		}
		post(0); 
	}

	return 0;
}

Code 02

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