数据结构--哈夫曼树与哈夫曼编码

哈夫曼树

什么是哈夫曼树

• 哈夫曼树是一类带权路径长度最短的二叉树，中文名叫哈(郝)夫曼树或最优二叉树。
• 相关概念：
  1.结点的路径长度：从根结点到该结点的路径上分支的数目。
  2.树的路径长度：树中每个结点的路径长度之和。
  3.树的带权路径长度：树中所有叶子结点的带权路径长度之和。

如何构建哈夫曼树

我们拥有不同的数出现的次数，也就是权值，哈夫曼树也是一颗二叉树，我们将所有权值按照从小到大的顺序存储在数组中，将最小和次小的两个数当成二叉树的左右结点，将这两个数移出数组并将两数之和入数组，进行同样的操作

具体步骤如下：

1.假设有n个权值，则构造出的哈夫曼树有n个叶子结点。 n个权值分别设为 w1、w2、…、wn
2.将w1、w2、…，wn看成是有n 棵树的森林(每棵树仅有一个结点)
3.在森林中选出两个根结点的权值最小的树合并，作为一棵新树的左、右子树，且新树的根结点权值为其左、右子树根结点权值之和
4.从森林中删除选取的两棵树，并将新树加入森林
5.重复2、3步，直到森林中只剩一棵树为止，该树即为所求得的哈夫曼树
6.注意：为了使得到的哈夫曼树的结构尽量唯一，通常规定生成的哈夫曼树中每个结点的左子树根结点的权小于等于右子树根结点的权

如：对下图中的六个带权叶子结点来构造一棵哈夫曼树，步骤如下：

哈夫曼编码

什么是哈夫曼编码

• 为了缩短总长度，采用不等长编码方式，构造哈夫曼树

如何构建哈夫曼编码

• 将每个字符的出现频率作为字符结点的权值赋予叶子结点，每个分支结点的左右分支分别用0和1编码，从树根结点到每个叶子结点的路径上
• 所经分支的0、1编码序列等于该叶子结点的二进制编码。如上文所示的哈夫曼编码如下：
  

a 的编码为：00
b 的编码为：01
c 的编码为：100
d 的编码为：1010
e 的编码为：1011
f 的编码为：11

代码实现

#include<malloc.h>
//哈夫曼树结点结构体 
typedef struct HuffmanTree{
	int weight;
	int id;
	struct HuffmanTree* lchild;
	struct HuffmanTree* rchild;
}HuffmanNode;

//构建哈夫曼树 
HuffmanNode* createHuffmanTree(int *a,int n){
	int i,j;
	HuffmanNode **temp,*hufmTree;
	temp=(HuffmanNode **)malloc(n*sizeof(HuffmanNode));
	//将数组a中的权值赋给结点中的weight
	for(i=0;i<n;i++){
		temp[i]=(HuffmanNode*)malloc(sizeof(HuffmanNode));
		temp[i]->weight=a[i];
		temp[i]->id=i;
		temp[i]->lchild=NULL;
		temp[i]->rchild=NULL;
	} 
	//min1、min2分别作为最小和次小权值的下标
	//先将最小的两个下标赋给small1、small2（注意：对应权值未必最小）
	for(i=0;i<n-1;i++){
		int min1=-1,min2;
		for(j=0;j<n;j++){
			if(temp[j]!=NULL&&min1==-1){
				min1=j;
				continue;
			}
			else if(temp[j]!=NULL){
				min2=j;
				break;
			}
		}
		//比较权值，挪动min1和min2使之分别成为最小和次小权值的下标
		for(j=min2;j<n;j++){
			if(temp[j]!=NULL){
				if(temp[j]->weight<temp[min1]->weight){
					min2=min1;
					min1=j;
				}
				else if(temp[j]->weight<temp[min2]->weight){
					min2=j;
				}
			}
		}
		hufmTree=(HuffmanNode*)malloc(sizeof(HuffmanNode));
		hufmTree->weight = temp[min1]->weight + temp[min2]->weight;
	    hufmTree->lchild = temp[min1];
	    hufmTree->rchild = temp[min2];
	    temp[min1] = hufmTree;
        temp[min2] = NULL;
	}
	free(temp);
    return hufmTree;
} 

//递归进行哈夫曼编码
// depth是哈夫曼树的深度
void HuffmanCode(HuffmanNode* hufmTree, int depth){
	static int code[10];
	if(hufmTree){
		if(hufmTree->lchild==NULL&&hufmTree->rchild==NULL){
			printf("id为%d权值为%d的叶子结点的哈夫曼编码为 ", hufmTree->id, hufmTree->weight);
	        int i;
            for(i=0;i<depth;i++){
            	printf("%d",code[i]);
			}
			printf("\n");
		}
		else{
			code[depth] = 0;
            HuffmanCode(hufmTree->lchild, depth+1);
            code[depth] = 1;
            HuffmanCode(hufmTree->rchild, depth+1);
		}
	}
} 
//哈夫曼解码
//ch是要解码的01串，string是结点对应的字符
void HuffmanDecode(char ch[], HuffmanNode* hufmTree, char string[]){
	int i;
	int num[100];
	HuffmanNode* tempTree=NULL;
	for(i=0;i<strlen(ch);i++){
		if(ch[i]=='0')
			num[i]=0;
		else
			num[i]=1;
	}
	if(hufmTree){
		i=0;
		while(i<strlen(ch)){
			tempTree=hufmTree;
			while(tempTree->lchild!=NULL&&tempTree->rchild!=NULL){
				if(num[i]==0){
					tempTree=tempTree->lchild;
				}
				else{
					tempTree=tempTree->rchild;
				}
				i++;	
			}
			printf("%c",string[tempTree->id]);
		}
	}
}  

int main(){
	int i,n;
	printf("请输入叶子结点的个数：\n");
	scanf("%d", &n);
	
	int* arr;
    arr=(int*)malloc(n*sizeof(int));
    printf("请输入%d个叶子结点的权值：\n", n);
	for(i=0; i<n; ++i)
		scanf("%d", &arr[i]);
		
	char ch[100],string[100];
	printf("请连续输入这%d个叶子结点各自所代表的字符：\n", n);
	fflush(stdin); // 强行清除缓存中的数据，也就是上面输入权值结束时的回车符
    gets(string);
    
    HuffmanNode* hufmTree = NULL;
    hufmTree = createHuffmanTree(arr, n);
    
    printf("\n各叶子结点的哈夫曼编码为：\n");
    HuffmanCode(hufmTree, 0);
    
    printf("要解码吗？请输入编码:\n");
    gets(ch);
    printf("解码结果为：\n");
    HuffmanDecode(ch, hufmTree, string);
    printf("\n");
 
    free(arr);
    free(hufmTree);

	return 0;
}