【堆的完全二叉树性质】PAT A1155 Heap Paths

题目描述

1155 Heap Paths (30分)

知识点

堆

实现

码前思考

1. 比较水的一道题。。。
2. 主要还是使用了完全二叉树可以使用数组静态实现的特性。

代码实现

//从1开始编号 
#include "bits/stdc++.h"
using namespace std;
const int maxn = 1e3+10;

int n;
int data[maxn];
bool isMax;
bool isHeap;
vector<int> path; 

void dfs(int root){
	//首先打印这个结点？
	//printf("%d",data[root]);
	path.push_back(data[root]);
	
	//如果这个结点没有左右孩子 
	int l = root*2;
	int r = root*2+1;
	if(l>n&&r>n){
		//打印输出
		for(int i=0;i<path.size();i++){
			printf("%d",path[i]);
			if(i!=path.size()-1){
				printf(" ");	
			}else{
				printf("\n");				
			}
		}
		path.pop_back();
		return;
	}else{
		//说明还有左右结点 
		if(r <= n){
			//查看右子树与自己的关系
			
			if(isHeap){//判断是否是堆 
				if(data[root] > data[r] && !isMax){
					isHeap = false;
				}
				if(data[root] < data[r] && isMax){
					isHeap = false;
				} 				
			}
			//接下来dfs 
			dfs(r); 
		}
		if(l <= n){
			if(isHeap){//判断是否是堆 
				if(data[root] > data[l] && !isMax){
					isHeap = false;
				}
				if(data[root] < data[l] && isMax){
					isHeap = false;
				} 				
			}
			//接下来dfs 
			dfs(l); 			
		}
		path.pop_back();
		return; 
	}
}

int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&data[i]);
	}
	if(data[1] > data[n]){
		//大根堆 
		isMax = true;
	}else{
		//小根堆 
		isMax = false;
	} 
	
	isHeap = true;
	
	//之后进行遍历
	dfs(1); 
	
	if(isHeap){
		if(isMax){
			printf("Max Heap");
		}else{
			printf("Min Heap");
		}
	}else{
		printf("Not Heap");
	} 
	return 0;
}

码后反思

1. 柳神把DFS和判断是否是堆分开了：

   #include <iostream>
   #include <vector>
   using namespace std;
   vector<int> v;
   int a[1009], n, isMin = 1, isMax = 1;
   void dfs(int index) {
       if (index * 2 > n && index * 2 + 1 > n) {
           if (index <= n) {
               for (int i = 0; i < v.size(); i++)
                   printf("%d%s", v[i], i != v.size() - 1 ? " " : "\n");
           }
       } else {
           v.push_back(a[index * 2 + 1]);
           dfs(index * 2 + 1);
           v.pop_back();
           v.push_back(a[index * 2]);
           dfs(index * 2);
           v.pop_back();
       }
   }
   int main() {
       cin >> n;
       for (int i = 1; i <= n; i++)
           scanf("%d", &a[i]);
       v.push_back(a[1]);
       dfs(1);
       for (int i = 2; i <= n; i++) {
           if (a[i/2] > a[i]) isMin = 0;
           if (a[i/2] < a[i]) isMax = 0;
       }
       if (isMin == 1)
           printf("Min Heap");
       else 
           printf("%s", isMax == 1 ? "Max Heap" : "Not Heap"); 
       return 0;
   }
   

二刷代码

第二次写卡了一下，在于没有考虑清楚作为一个叶子结点应该具备哪些性质：

//首先根据第一个和最后一个元素判断它应该为什么堆~ 
//数组下标从1开始 
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int maxn = 1010;

int heap[maxn];
int n; 
bool isHeap=true;
bool isMaxHeap=true;
vector<int> path;
vector<vector<int> > res;  

void preOrder(int root){
	if(root<=n){
		if(root>n/2){//说明到达了叶子节点 
			path.push_back(heap[root]);
			res.push_back(path);
			//那么就遍历path，进行审查
			if(isMaxHeap){//说明是大根堆 
				for(int i=1;i<path.size();i++){
					if(path[i]>path[i-1]){
						isHeap=false;
					}
				} 
			}else{//说明是小根堆
				for(int i=1;i<path.size();i++){
					if(path[i]<path[i-1]){
						isHeap=false;
					}
				} 			
			}
			path.pop_back(); 
		}else{
			path.push_back(heap[root]);
			preOrder(root*2+1);
			preOrder(root*2);
			path.pop_back();//弹出
			return; 
		}		
	}

	return;
}

int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&heap[i]);
	}
	if(heap[1]>heap[n]){
		isMaxHeap=true;
	}else{
		isMaxHeap=false; 
	}
	
	//然后进行模拟的先序遍历
	preOrder(1); 
	
	//输出
	for(int i=0;i<res.size();i++){
		vector<int> path=res[i];
		for(int j=0;j<path.size();j++){
			printf("%d%c",path[j],j==path.size()-1?'\n':' ');
		}
	}
	
	if(isHeap){
		if(isMaxHeap){
			printf("Max Heap\n");
		}else{
			printf("Min Heap\n");
		}
	}else{
		printf("Not Heap\n");
	}
	
	return 0;
}