最大堆的实现及相关操作

最大堆的实现及相关操作

#include<iostream>
#include<queue> 
using namespace std;

#define MaxData 10000
typedef int ElementType;
typedef struct HeapStruct* MaxHeap;
struct HeapStruct{
	ElementType* Elements;	//存储 元素的数组 
	int Size;     //堆的当前元素个数 
	int Capacity;   //堆的最大容量 
}; 
//1.创建容量为MaxSize的空的最大堆 
MaxHeap Create(int MaxSize);
//2.最大堆元素的插入 
void Insert(MaxHeap H,ElementType item);
//3.最大堆的删除 
ElementType DeleteMax(MaxHeap H); 
//4.判断最大堆是否已满 
bool IsFull(MaxHeap H); 
//5.判断最大堆是否为空 
bool IsEmpty(MaxHeap H); 


//6.创造最大堆
void PercDown(MaxHeap H,int p); 
void BuildHeap(MaxHeap H);
//7.层次遍历 
void LevelOrderTraversal(MaxHeap H); 

int main(){
	int N;
	scanf("%d",&N);
	MaxHeap H=Create(N);
	for(int i=1;i<N+1;i++){
		scanf("%d",&H->Elements[i]);
		H->Size++;
	}
	BuildHeap(H);
	LevelOrderTraversal(H);
	
	return 0;
} 


MaxHeap Create(int MaxSize){
	MaxHeap H=(MaxHeap)malloc(sizeof(HeapStruct));
	H->Elements=(ElementType*)malloc((MaxSize+1)*sizeof(ElementType));
	H->Size=0;								 //MaxSize+1是因为最大堆是从下标为1的数组开始存储的 
	H->Capacity=MaxSize;
	H->Elements[0]=MaxData;
			/*定义“哨兵”为大于堆中所有元素的值，便于以后更快的操作*/
	return H; 
}

void Insert(MaxHeap H,ElementType item){
	int i;
	if(IsFull(H)){
		printf("最大堆已满");
		return ;
	} 
	i=++H->Size;
	for(;H->Elements[i/2]<item;i/=2){//没有H->Elements[0]这个哨兵的话判断条件中i要大于1 
		H->Elements[i]=H->Elements[i/2];
	}
	H->Elements[i]=item;
} 

ElementType DeleteMax(MaxHeap H){
	//从最大堆H中取出键值魏最大的元素，并删除 
	int Parent,Child;
	ElementType MaxItem,temp;
	if(IsEmpty(H)){
		printf("最大堆已空");
		return NULL;
	}
	MaxItem=H->Elements[1]; //取出根节点最大值 
	//用最大堆中最后一个元素从根节点开始 
	temp=H->Elements[H->Size--];
	for(Parent=1;Parent*2<=H->Size;Parent=Child){
		Child=Parent*2;
		if((Child!=H->Size)&&(H->Elements[Child]<H->Elements[Child+1]))
			Child++;
		if(temp>=H->Elements[Child])break;
		else{
			H->Elements[Parent]=H->Elements[Child];
		} 
	}
	H->Elements[Parent]=temp;
	return MaxItem;
}

bool IsEmpty(MaxHeap H){
	return (H->Size==0);
}

bool IsFull(MaxHeap H){
	return (H->Size==H->Capacity);
}

void LevelOrderTraversal(MaxHeap H){
	queue<int>Q;
	if(IsEmpty(H)){
		printf("最大堆为空!");
		return ;
	}
	else{
		int i=1;
		Q.push(i);
		while(!Q.empty()){
			int x=Q.front();
			Q.pop();
			printf("%d ",H->Elements[x]);
			x*=2; 
			if(x<=H->Size)Q.push(x);
			if(x+1<=H->Size)Q.push(x+1);
		}
	}
}
/*---------------------创建大根堆----------------------------*/
void PercDown(MaxHeap H,int p){
	//将H中以H->Data[p]为根的子堆调整为最大堆
	int Parent,Child;
	ElementType X;
	
	X=H->Elements[p]; //取出根节点的值；
	for(Parent=p;Parent*2<=H->Size;Parent=Child){
		Child=Parent*2;
		if((Child!=H->Size)&&(H->Elements[Child]<H->Elements[Child+1]))
			Child++;
		if(X>=H->Elements[Child])break;
		else
			H->Elements[Parent]=H->Elements[Child];
	} 
	H->Elements[Parent]=X;
}

void BuildHeap(MaxHeap H){
	//调整H->Elements[]中的元素，使满足最大堆的有序性
	//这里假设所有H->Size 个元素已经存在H->Element[]中
	
	int i;
	
	//从最后一个结点的父节点开始，到根节点1
	for(i=H->Size/2;i>0;i--)
		PercDown(H,i); 
}