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 <stdlib.h>
#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;
}