哈夫曼编码（HDU 1053）

哈夫曼树与哈夫曼编码

在一般的数据结构的书中，树的那章后面，著者一般都会介绍一下哈夫曼(HUFFMAN)树和哈夫曼编码。哈夫曼编码是哈夫曼树的一个应用。哈夫曼编码应用广泛，如JPEG中就应用了哈夫曼编码。 首先介绍什么是哈夫曼树。哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的 路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的带权路径长度记为WPL= (W1*L1+W2*L2+W3*L3+...+Wn*Ln)，N个权值Wi(i=1,2,...n)构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li(i=1,2,...n)。可以证明哈夫曼树的WPL是最小的。

哈夫曼编码步骤：

一、对给定的n个权值{W1,W2,W3,...,Wi,...,Wn}构成n棵二叉树的初始集合F= {T1,T2,T3,...,Ti,...,Tn}，其中每棵二叉树Ti中只有一个权值为Wi的根结点，它的左右子树均为空。（为方便在计算机上实现算 法，一般还要求以Ti的权值Wi的升序排列。）
二、在F中选取两棵根结点权值最小的树作为新构造的二叉树的左右子树，新二叉树的根结点的权值为其左右子树的根结点的权值之和。
三、从F中删除这两棵树，并把这棵新的二叉树同样以升序排列加入到集合F中。
四、重复二和三两步，直到集合F中只有一棵二叉树为止。

简易的理解就是，假如我有A,B,C,D,E五个字符，出现的频率（即权值）分别为5,4,3,2,1,那么我们第一步先取两个最小权值作为左右子树构造一个新树，即取1，2构成新树，其结点为1+2=3，如图：

虚线为新生成的结点，第二步再把新生成的权值为3的结点放到剩下的集合中，所以集合变成{5,4,3,3}，再根据第二步，取最小的两个权值构成新树，如图：

再依次建立哈夫曼树，如下图：

其中各个权值替换对应的字符即为下图：

所以各字符对应的编码为：A->11,B->10,C->00,D->011,E->010

霍夫曼编码是一种无前缀编码。解码时不会混淆。其主要应用在数据压缩，加密解密等场合。

#include<stdio.h>
#include<string.h>
#define MAX 99999999


struct huffcode                //哈夫曼编码 
{
	int bit[200];              //编码 
	int start;               //编码开始的位置 
};
struct huff               //哈夫曼树节点 
{
	int weight;             //哈夫曼节点的权值 
	int parent;             //哈夫曼节点的树节点 
	int lchild,rchild;       //哈夫曼树节点的左右子节点 
};


huff hf[200];
huffcode hfc[200],cd;
int alp[28],cnt,m;
char str[100000];



void creatHuffman()           //生成哈夫曼树 
{

	int m1,m2,x1,x2;
	
	
	for(int i=0;i<cnt-1;i++)       //因为每次2个进行合并，所以一共需要cnt-1次 
	{
		m1 = m2 = MAX;
		x1 = x2 = 0;
		for(int j=0;j<cnt+i;j++)    //寻找权值最小的两个节点 
		{
			if(hf[j].weight<m1 && hf[j].parent==-1)
			{
				m2 = m1;
				x2 = x1;
				m1 = hf[j].weight;
				x1 = j;
			}
			else if(hf[j].weight<m2 && hf[j].parent==-1)
			{
				m2 = hf[j].weight;
				x2 = j;
			}
		}
		
		hf[x1].parent = cnt+i;         //权值最小的两个节点合成一个新的节点 
		hf[x2].parent = cnt+i;
		
		hf[cnt+i].weight = hf[x1].weight+hf[x2].weight;
		hf[cnt+i].lchild = x1;
		hf[cnt+i].rchild = x2;
		
	}
}

int main()
{
	int len;
	while(scanf("%s", str),strcmp(str,"END")!=0)
	{
		
		memset(alp, 0, sizeof(alp));
		len = strlen(str);
		for(int i=0;i<len;i++)
		{
			if(str[i]=='_')
			{
				alp[26] ++;
			}
			else
			{
				alp[str[i]-'A'] ++;
			}
		}
		
		cnt = 0;
		for(int i=0;i<27;i++)
		{
			if(alp[i]!=0)
			{
				hf[cnt++].weight = alp[i];
			}
		}
		
		if(cnt==1)       //当只有一种字符的时候，要进行单独考虑 
		{
			printf("%d %d 8.0\n", len*8,len);
			continue;
		}
		
		m = 2*cnt-1;    //当有多个字符时候，用哈夫曼编码进行解析 
		for(int i=0;i<m;i++)
		{
			hf[i].parent = -1;
			hf[i].rchild = -1;
			hf[i].lchild = -1;
		}
		
		creatHuffman();
		
		for(int i=0;i<cnt;i++)    //将哈夫曼树转化成哈夫曼编码 
		{
			cd.start = cnt-1;
			int p = hf[i].parent;
			int c = i;
			while(p!=-1)
			{
				if(hf[p].lchild==c)
				{
					cd.bit[cd.start] = 0;
				}
				else if(hf[p].rchild==c)
				{
					cd.bit[cd.start] = 1;
				}
				cd.start --;
				c = p;
				p = hf[c].parent;
			}
			
			for(int j=cd.start+1;j<cnt;j++)
			{
				hfc[i].bit[j] = cd.bit [j];
			}
			
			hfc[i].start = cd.start+1;
		}
		
		int dissum = 0;
		for(int i=0;i<cnt;i++)
		{
			dissum += hf[i].weight*(cnt-hfc[i].start);
		}
		printf("%d %d %.1f\n", len*8, dissum, (len*8.0)/dissum);
	}
	return 0;
}