二叉堆--C语言实现

binheap.h

#ifndef _BINHEAP_H_
#define _BINHEAP_H_
#define MinPQSize 100

struct HeapStruct;
typedef int ElementType;
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);

#endif

binheap.c

#include
#include
#include"binheap.h"

struct HeapStruct
{
    int Capacity;
    int Size;
    ElementType *Elements;
};

PriorityQueue Initialize(int MaxElements)
{
    PriorityQueue H;
    if (MaxElements < MinPQSize)
    {
        printf("ERROR!\n");
        return NULL;
    }
    H = (PriorityQueue)malloc(sizeof(struct HeapStruct));
    if (H == NULL)
    {
        printf("FAILURE!\n");
        return NULL;
    }
    H->Elements = (ElementType*)malloc(sizeof(ElementType)*
        (MaxElements + 1));
    if (H->Elements == NULL)
    {
        printf("FAILURE!\n");
        return NULL;
    }
    H->Capacity = MaxElements;
    H->Size = 0;
    H->Elements[0] = INT_MIN;
    return H;
}
void Destroy(PriorityQueue H)
{
    if (!H)
        free(H->Elements);
}
void MakeEmpty(PriorityQueue H)
{
    H->Size = 0;
}
void Insert(ElementType X, PriorityQueue H)
{
    int i;
    if (IsFull(H))
    {
        printf("ERROR!\n");
        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))
    {
        printf("ERROR!\n");
        return 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(!H)
        return H->Elements[1];  
    return NULL;
}
int IsEmpty(PriorityQueue H)
{
    return H->Size == 0;
}
int IsFull(PriorityQueue H)
{
    return H->Size == H->Capacity;
}