Heap(堆)学习——C语言描述

头文件内容如下:

#ifndef _BinHeap_H
#define _BinHeap_H

typedef int ElementType;

struct HeapStruct;
typedef struct HeapStruct *PriorityQueue;

PriorityQueue Initialize(int MaxElements);
void Destroy (PriorityQueue H);
void MakeEmpty(PriorityQueue H);
void Insert(ElementType X, PriorityQueue H);
ElementType DeleteMin(PriorityQueue H);
ElementType FindMin(PriorityQueue H);
int IsEmpty(PriorityQueue H);
int IsFull(PriorityQueue H);
void DecreaseKey(unsigned int P, unsigned int D, PriorityQueue H);
void IncreaseKey(unsigned int P, unsigned int D, PriorityQueue H);
void Delete(unsigned int P, PriorityQueue H);
PriorityQueue BuildHeap(ElementType Arr[], unsigned int Len);

#endif

源文件如下:

#include "BinHeap.h"
#include 
#include "Fatal.h"

#define MinPQSize (10)
#define MinData (-9999)
struct HeapStruct
{
	int Capacity;
	int Size;
	ElementType *Elements;
};

PriorityQueue
Initialize(int MaxElements)
{
	PriorityQueue H;
	if(MaxElements < MinPQSize)
	{
		Error("Priority queue size is too small");
	}

	H = malloc(sizeof(struct HeapStruct));
	if(H == NULL)
	{
		FatalError("Out of space!");
	}

	// Allocate the array plus one extra for sentinel
	H->Elements = malloc((MaxElements + 1) * sizeof(ElementType));
	if(H->Elements == NULL)
	{
		FatalError("Out of space!");
	}
	H->Capacity = MaxElements;
	H->Size = 0;
	H->Elements[0] = MinData;

	return H;
}

void
Destroy(PriorityQueue H)
{
	free(H->Elements);
	free(H);
}


void
MakeEmpty(PriorityQueue H)
{
	H->Size = 0;
}

void
Insert(ElementType X, PriorityQueue H)
{
	int i;
	if(IsFull(H))
	{
		Error("Priority Queue is full");
		return;
	}

	for(i = ++H->Size; H->Elements[i/2] > X; i /= 2)
		H->Elements[i] = H->Elements[i/2];
	H->Elements[i] = X;
}

ElementType
DeleteMin(PriorityQueue H)
{
	int i, Child;
	ElementType MinElement, LastElement;

	if(IsEmpty(H))
	{
		Error("Priority Queue is Is Empty");
		return H->Elements[0];
	}
	MinElement = H->Elements[1];
	LastElement = H->Elements[H->Size--];
	for(i = 1; i * 2 <= H->Size; i = Child)
	{
		Child = i * 2;
		if( Child != H->Size && 
			H->Elements[Child + 1] < H->Elements[Child])
			Child ++;
		if(LastElement > H->Elements[Child])
			H->Elements[i] = H->Elements[Child];
		else
			break;
	}
	H->Elements[i] = LastElement;
	return MinElement;
}

ElementType
FindMin(PriorityQueue H)
{
	if(!IsEmpty(H))
		return H->Elements[1];
	else
	{
		Error("Priority Queue is Empty");
		return H->Elements[0];
	}
}

int
IsEmpty(PriorityQueue H)
{
	return H->Size == 0;
}

int
IsFull(PriorityQueue H)
{
	return H->Size == H->Capacity;
}

static void
PercolateUp(unsigned int P, PriorityQueue H)
{
	if(P > H->Size)
	{
		Error("Overflow");
		return;
	}
	ElementType X = H->Elements[P];
	for( ; H->Elements[P/2] > X; P /= 2)
		H->Elements[P] = H->Elements[P/2];
	H->Elements[P] = X;
}

static void
PercolateDown(unsigned int P, PriorityQueue H)
{
	int i,Child;
	ElementType X;
	if(P > H->Size)
	{
		Error("Overflow");
		return;
	}

	X = H->Elements[P];
	for(i = P; i * 2 <= H->Size; i = Child)
	{
		Child = i * 2;
		if( Child != H->Size && 
			H->Elements[Child + 1] < H->Elements[Child])
			Child ++;
		if(X > H->Elements[Child])
			H->Elements[i] = H->Elements[Child];
		else
			break;
	}
	H->Elements[i] = X;
}

void
DecreaseKey(unsigned int P, unsigned int D, PriorityQueue H)
{
	if(P > H->Size)
	{
		Error("Overflow");
		return;
	}
	H->Elements[P] -= D;
	PercolateUp(P,H);
}

void
IncreaseKey(unsigned int P, unsigned int D, PriorityQueue H)
{
	if(P > H->Size)
	{
		Error("Overflow");
		return;
	}
	H->Elements[P] += D;
	PercolateDown(P,H);
}
void
Delete(unsigned int P, PriorityQueue H)
{
	DecreaseKey(P,10,H);
	DeleteMin(H);
}

PriorityQueue
BuildHeap(ElementType Arr[], unsigned int Len)
{
	PriorityQueue H;
	int i;

	H = malloc(sizeof(struct HeapStruct));
	if(H == NULL)
	{
		FatalError("Out of space!");
	}

	// Allocate the array plus one extra for sentinel
	H->Elements = malloc((Len + 1) * sizeof(ElementType));
	if(H->Elements == NULL)
	{
		FatalError("Out of space!");
	}
	H->Elements[0] = MinData;
    H->Capacity = Len;
    for(i = 0; i < Len; i++)
    {
        Insert(Arr[i], H);
    }
//	for(i = 1; i <= Len; i++)
//	{
//		H->Elements[i] = Arr[i-1];
//	}
//	H->Capacity = Len;
//	H->Size = Len;

//	for(i = Len / 2; i > 0; i--)
//		PercolateDown(i,H);

	return H;
}