HDOJ 1053 Huffman编码 自写优先队列的ADT 权当做练习数据结构

//BinHeap.h
#ifndef _BinHeap_H

struct PriorityQueueNode;
struct ElementTypeNode;

typedef struct PriorityQueueNode PQN;
typedef struct PriorityQueueNode *PriorityQueue;

typedef struct ElementTypeNode ETN;
typedef struct ElementTypeNode *ElementType;

/*Methods of Priority Queue*/
PriorityQueue Initialize(int MaxElements);
int IsEmpty(PriorityQueue H);
int IsFull(PriorityQueue H);

/*Warning Type ETN has not been complete*/
void Insert(ETN X, PriorityQueue H);

ETN DeleteMin(PriorityQueue H);
void Destroy(PriorityQueue H);

#endif

//BinHeap.c
#include <stdio.h>
#include "BinHeap.h"
#define MinPQSize 1
#define IrrelevantWord '#'
#define MinKey 0
#define Bin 2

struct PriorityQueueNode
{
int Capacity;
int Size;
ElementType Elements;
};

struct ElementTypeNode
{
char Word;
int Key;
};

PriorityQueue Initialize(int MaxElements)
{
PriorityQueue H;

if(MaxElements < MinPQSize)
printf("Size Error!PQ size is too small!\n");

H = malloc(sizeof(struct PriorityQueueNode));
if(H == NULL)
printf("H Malloc Error!\n");

/*Allocate the array plus one extra for sentinel*/
H->Elements = malloc( (MaxElements + 1) * sizeof(struct ElementTypeNode));
if(H->Elements == NULL)
printf("H->Elements Malloc Error!\n");

H->Capacity = MaxElements;
H->Size = 0;

H->Elements[0].Word = IrrelevantWord;
H->Elements[0].Key = MinKey;

return H;
}

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

int IsFull(PriorityQueue H)
{
if(H->Size == H->Capacity)
return 1;
else
return 0;
}

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

void Insert(ETN X, PriorityQueue H)
{
int i;

if( IsFull(H) )
{
printf("Priority Queue is full!\n");
return ;
}

for(i = ++ H->Size; H->Elements[i/Bin].Key > X.Key; i/=Bin)
{
H->Elements[i] = H->Elements[i/Bin];
}

H->Elements[i] = X;
}

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

if( IsEmpty(H))
{
printf("PQ is empty!\n");
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].Key < H->Elements[Child].Key)
Child++;

if(LastElement.Key > H->Elements[Child].Key)
H->Elements[i] = H->Elements[Child];
else
break;
}

H->Elements[i] = LastElement;

return MinElement;
}

//HuffCode.c
#include "BinHeap.c"
#include <string.h>
#define CharacterTypes 27
#define CharacterLen 100
#define CharacterEnd "END"
#define StandardCharacterLength 8

int HuffCodeLength(PriorityQueue H)
{
int Length = 0;
ETN Tmp1,Tmp2;

if(H->Size <= 0)
return Length;
if(H->Size == 1)
return Length + 1;

while(H->Size > 1)
{
Tmp1 = DeleteMin(H);
Tmp2 = DeleteMin(H);
Length += (Tmp1.Key + Tmp2.Key);
Tmp1.Key += Tmp2.Key;
Insert(Tmp1,H);
}
DeleteMin(H);
return Length;
}

int main()
{
char TheString[CharacterLen];
char Characters[CharacterTypes];
PriorityQueue H;
ETN Tmp;
int i,StandardResult,HuffCodeResult;
H = Initialize(CharacterLen);
while(1)
{
gets(TheString);
if( strcmp(CharacterEnd,TheString) == 0)
break;

for(i = 0; i < CharacterTypes; i++)
Characters[i] = 0;
/*
for(i = 0; i < strlen(TheString); i++)
printf("%c",TheString[i]);
printf("\n");
*/
for(i = 0; i < strlen(TheString); i++)
{
if(TheString[i] == '_')
Characters[CharacterTypes-1]++;
else
Characters[TheString[i]-'A']++;
}
/*
for(i = 0; i < CharacterTypes; i++)
{
printf("%d ",Characters[i]);
}
printf("\n");
*/

for(i = 0; (i < CharacterTypes); i++)
{
if( Characters[i] <= 0 )
continue;
Tmp.Word = (char)('A' + i);
Tmp.Key = Characters[i];
Insert(Tmp,H);
}
StandardResult = StandardCharacterLength * strlen(TheString);
/*Huffman Code Len*/
HuffCodeResult = HuffCodeLength(H);
printf("%d %d %.1f\n",StandardResult,HuffCodeResult,(float)StandardResult/HuffCodeResult);
/**************/
}

Destroy(H);
return 0;
}