PAT-ADVANCED1147——Heaps

我的PAT-ADVANCED代码仓：https://github.com/617076674/PAT-ADVANCED

原题链接：https://pintia.cn/problem-sets/994805342720868352/problems/994805342821531648

题目描述：

题目翻译：

1147 堆

在计算机科学中，堆是一种专门的基于树的数据结构，它满足堆属性：如果P是C的父节点，则P的键（值）大于或等于（在最大堆中） 或者小于或等于（在最小堆中）C的键值。堆的常见实现是二叉堆，其中树是完整的二叉树。（引自维基百科，网址为https://en.wikipedia.org/wiki/Heap_(data_structure））

你的任务是判断给定的完全二叉树是否为堆。

输入样例：

每个输入文件包含一个测试用例。对每个测试用例，第一行给出两个正整数：M(<= 100)，代表要测试的树的数量；和N(1 < N <= 1000)，代表每棵树中的节点数。然后是M行，每行包含N个不同的整数键（全部在int范围内），它给出了完整二叉树的层序遍历序列。

输出样例：

对于每个给定的树，如果它是最大堆，则在一行中打印“Max Heap”，或者对于最小堆打印“Min Heap”，如果它根本不是堆，则打印“Not Heap”。然后在下一行打印树的后序遍历序列。所有数字都用空格分隔，并且在行的开头或结尾不能有额外的空格。

输入样例：

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

输出样例：

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

知识点：堆、树的后序遍历

思路：首先判断是否是堆，以及最小堆还是最大堆，再根据数组建立完全二叉树，后序遍历之得到后序遍历结果

如果堆是从数组的索引0开始，那么其左孩子为2 * i + 1，右孩子为2 * i + 2。

如果堆是从数组的索引1开始，那么其左孩子为2 * i，右孩子为2 * i + 1。

由于对每个序列都需要建立一棵树，不方便用静态数组来表示，因此用指针的形式来表示树中的节点的左右孩子。

时间复杂度和空间复杂度是O(M * N)。

C++代码：

#include<iostream>
#include<vector>

using namespace std;

struct node{
	int data;
	node* lchild;
	node* rchild;
};

bool isMaxHeap(vector<int> levelOrder);	//判断是否是最大堆 
bool isMinHeap(vector<int> levelOrder);	//判断是否是最小堆 
node* newNode(int num);	//新建节点 
node* create(vector<int> levelOrder);	//根据层序遍历建立树，返回树的根节点 
void postOrderTraversal(node* head, vector<int> &postOrder);	//后序遍历 

int main(){
	int M, N;
	scanf("%d %d", &N, &M);
	for(int i = 0; i < N; i++){
		vector<int> levelOrder;
		int num;
		for(int j = 0; j < M; j++){
			scanf("%d", &num);
			levelOrder.push_back(num);
		}
		if(isMaxHeap(levelOrder)){
			printf("Max Heap\n");
		}else if(isMinHeap(levelOrder)){
			printf("Min Heap\n");
		}else{
			printf("Not Heap\n");
		}
		node* head = create(levelOrder);
		vector<int> postOrder;
		postOrderTraversal(head, postOrder);
		for(int j = 0; j < postOrder.size(); j++){
			printf("%d", postOrder[j]);
			if(j != postOrder.size() - 1){
				printf(" ");
			}else{
				printf("\n");
			}
		}
	}
	return 0;
}

bool isMaxHeap(vector<int> levelOrder){
	for(int i = 0; i < levelOrder.size(); i++){
		if(2 * i + 1 < levelOrder.size()){
			if(levelOrder[2 * i + 1] > levelOrder[i]){
				return false;
			}
		}
		if(2 * i + 2 < levelOrder.size()){
			if(levelOrder[2 * i + 2] > levelOrder[i]){
				return false;
			}
		}
	}
	return true;
}

bool isMinHeap(vector<int> levelOrder){
	for(int i = 0; i < levelOrder.size(); i++){
		if(2 * i + 1 < levelOrder.size()){
			if(levelOrder[2 * i + 1] < levelOrder[i]){
				return false;
			}
		}
		if(2 * i + 2 < levelOrder.size()){
			if(levelOrder[2 * i + 2] < levelOrder[i]){
				return false;
			}
		}
	}
	return true;
}

node* newNode(int num){
	node* head = new node();
	head->data = num;
	head->lchild = NULL;
	head->rchild = NULL;
	return head;
}

node* create(vector<int> levelOrder){
	vector<node*> nodes;
	for(int i = 0; i < levelOrder.size(); i++){
		nodes.push_back(newNode(levelOrder[i]));
	}
	for(int i = 0; i < nodes.size(); i++){
		if(2 * i + 1 < nodes.size()){
			nodes[i]->lchild = nodes[2 * i + 1];
		}
		if(2 * i + 2 < nodes.size()){
			nodes[i]->rchild = nodes[2 * i + 2];
		}
	}
	return nodes[0];
}

void postOrderTraversal(node* head, vector<int> &postOrder){
	if(head == NULL){
		return;
	}
	postOrderTraversal(head->lchild, postOrder);
	postOrderTraversal(head->rchild, postOrder);
	postOrder.push_back(head->data);
}

C++解题报告：