/*
Name: 赫夫曼编码（优先队列实现）
Copyright:
Author: 巧若拙
Date: 28/09/14 12:17
Description:
采用优先队列把一个普通线性表改造成赫夫曼树，再进行赫夫曼编码，得到一个同时记录了明文和对应编码的密码本。
使用优先队列（最小堆）构造赫夫曼树是一种高效的方法，比每次都遍历整个线性表要快很多。
我在构造密码本时确保密码本数组递增排序，这样每次插入新结点时可以折半查找插入，效率较高。
有序的密码本在把明文编码成密文时也可以大大提高查找效率。
*/
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<math.h>
#include<time.h>
#define MAXSIZE 300
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef char ElemType;
typedef int Status; //函数类型，其值是函数结果状态代码，如OK等
typedef struct {
ElemType data;
int weight;
int parent;
int lchild;
int rchild;
} HNodeType; //结点结构体
typedef struct {
ElemType data; //明文信息
char *code; //密文信息
} HCodeType; //编码结构体
void BuildMinHeap(HNodeType Hf[], int n);//将线性表Hf改造成一个最小堆
void MinHeapSiftDown(HNodeType Hf[], int n, int pos);//向下调整二叉堆的第pos个元素，使其满足最小堆的特征
void HuffmanTree (HNodeType Hf[], int n);//将线性表改造成赫夫曼树
void DisplayCodebook(HCodeType Cb[], int n);//显示密码本中的明码和对应密码信息
int InsertCodeLib(HCodeType Cb[], int n, ElemType x, char *s, int len);//将新结点插入到密码本的编码线性表中
int HfCoding(HCodeType Cb[], HNodeType Hf[], int n);//根据赫夫曼树进行赫夫曼编码，生成密码本
int main(void)
{
HNodeType Hf[MAXSIZE*2]; //赫夫曼树
HCodeType codebook[MAXSIZE]; //密码本
int lenHf = 5; //赫夫曼树叶子结点个数
int lenCb; //密码本长度（等于lenHf）
int i;
for (i=0; i<lenHf; i++) //随机产生数据和权值
{
Hf[i].data = ‘A‘ + i;
Hf[i].weight = rand() % 10 + 1;
printf("%c : %d\n", Hf[i].data, Hf[i].weight);
}
HuffmanTree (Hf, lenHf); //将线性表改造成赫夫曼树
lenCb = HfCoding(codebook, Hf, lenHf*2-1);//根据赫夫曼树进行赫夫曼编码，生成密码本
puts("密码本：");
DisplayCodebook(codebook, lenCb);//显示密码本中的明码和对应密码信息
return 0;
}
/*
函数功能：将线性表改造成赫夫曼树
初始条件：非递减线性表Hf已经存在
操作结果：先将原线性表改造成最小堆（优先队列），然后按照如下顺序处理该最小堆：
删除权重最小的两个结点，并将他们加入到队列尾部，将该两个最小结点的权值相加，生成一个新结点，并将新结点加入到优先队列。
不断调整该最小堆，直到只剩下一个结点，即得到赫夫曼树。
注意：每次产生新结点时，只需设置新结点的权重及孩子结点信息，双亲结点信息等赫夫曼树构造完毕后再统一计算。
*/
void HuffmanTree (HNodeType Hf[], int n)
{
int i;
int len = 2*n - 1;
int front = n -1;
int rear = len - 1;
BuildMinHeap(Hf, n);
for (i=0; i<len; i++) //初始化孩子结点位置
{
Hf[i].lchild = Hf[i].rchild = -1;
}
while (front > 0)
{
//删除权重最小的两个结点，并将他们加入到队列尾部
Hf[rear] = Hf[0];
Hf[0] = Hf[front];
MinHeapSiftDown(Hf, front+1, 1);//向下调整二叉堆的第1个元素，使其满足最小堆的特征
Hf[rear-1] = Hf[0];
//设置新结点的权重及孩子结点信息
Hf[0].weight = Hf[rear].weight + Hf[rear-1].weight;
Hf[0].lchild = rear;
Hf[0].rchild = rear - 1;
MinHeapSiftDown(Hf, front, 1);//向下调整二叉堆的第1个元素，使其满足最小堆的特征
rear -= 2; //由于有两个结点加入新队列，队尾指示前移2位
front--;//由于有（2-1 = 1）结点出列，队头指示前移1位
}
//计算父亲结点位置
Hf[0].parent = -1;
for (i=0; i<len; i++)
{
Hf[Hf[i].lchild].parent = Hf[Hf[i].rchild].parent = i;
}
}
/*
函数功能：将新结点插入到密码本的编码线性表中
初始条件：每个编码的明文和密文信息分别记录在x和s中，len是字符串s的长度
操作结果：先折半查找插入位置，然后插入新结点，将x和s的信息复制给新结点，注意s中存储的结点编码的路径是从叶子到根，存储到密码本时需要逆序复制 。
*/
int InsertCodeLib(HCodeType Cb[], int n, ElemType x, char *s, int len)//采用二分查找插入排序
{
int i, mid;
int left = 0, right = n-1;
while (left <= right)//折半查找插入位置
{
mid = (left + right) / 2;
if (x > Cb[mid].data)
{
left = mid + 1;
}
else
{
right = mid -1;
}
}
//新数据，执行插入操作
for (i=n; i>left; i--)
{
Cb[i] = Cb[i-1];
}
Cb[left].code = (char*)malloc(sizeof(char)*(len+1));
if (!Cb[left].code)
{
printf("Out of space!");
exit(0);
}
for (i=len-1; i>=0; i--) //把s的字符串逆序复制到code
{
Cb[left].code[len-1-i] = s[i];
}
Cb[left].code[len] = ‘\0‘;
Cb[left].data = x;
return n+1;
}
/*
函数功能：根据赫夫曼树进行赫夫曼编码，生成密码本
初始条件：赫夫曼树Hf已经存在，n是赫夫曼树的长度
操作结果：对赫夫曼树的叶子结点进行编码，并存储到密码本，返回密码本长度。
对密码本中的各个结点采用二分查找插入，构造非递减序列，以便于查找和编码。
*/
int HfCoding(HCodeType Cb[], HNodeType Hf[], int n)
{
int i, j, k, f;
int top = 0; //为编码结构体构造一个栈，top指示栈顶
char str[MAXSIZE]; //存储编码的临时字符串
for (i=0; i<n; i++)
{
if (Hf[i].lchild == -1)//是叶子结点
{
j = i;
f = Hf[j].parent;
k = 0;
while (f != -1) //逆序存储该结点的编码，注意结点编码的路径是从叶子到根，存储到密码本时需要逆序复制
{
if (j == Hf[f].lchild)
{
str[k++] = ‘0‘;
}
else
{
str[k++] = ‘1‘;
}
j = f;
f = Hf[j].parent;
}
str[k] = ‘\0‘;
top = InsertCodeLib(Cb, top, Hf[i].data, str, k);//采用二分查找插入排序
}
}
return top;
}
/*
函数功能：显示密码本中的明码和对应密码信息
初始条件：密码本已经存在
操作结果：显示密码本中的明码和对应密码信息。
*/
void DisplayCodebook(HCodeType Cb[], int n)
{
int i, j;
for (i=0; i<n; i++)
{
printf("%c: ", Cb[i].data);
puts(Cb[i].code);
}
}
/*
函数功能：向下调整二叉堆的第pos个元素，使其满足最小堆的特征
初始条件：最小堆Hf已经存在，只有第pos个元素不满足特征
操作结果：向下调整二叉堆的第pos个元素，使其满足最小堆的特征。
*/
void MinHeapSiftDown(HNodeType Hf[], int n, int pos)
{
HNodeType temp = Hf[pos-1];
int child = pos * 2; //指向左孩子
while (child <= n)
{
if (child < n && Hf[child-1].weight > Hf[child].weight) //有右孩子，且右孩子更小些，定位其右孩子
child += 1;
if (Hf[child-1].weight < temp.weight) //通过向上移动孩子结点值的方式，确保双亲大于孩子
{
Hf[pos-1] = Hf[child-1];
pos = child;
child = pos * 2;
}
else
break;
}
Hf[pos-1] = temp; //将temp向下调整到适当位置
}
/*
函数功能：将线性表Hf改造成一个最小堆
初始条件：线性表Hf已经存在
操作结果：将线性表Hf改造成一个最小堆
*/
void BuildMinHeap(HNodeType Hf[], int n)
{
int i;
for (i=n/2; i>0; i--)
{
MinHeapSiftDown(Hf, n, i);
}
}