哈夫曼树算法

问题描述：

找出存放一串字符所需的最少的二进制编码，在编码中每个字符的出现次数不同，而每个字符都可以用唯一的前缀码表示，这时我们就需要考虑根据每个字符在字符串中出现的频率（即权重）来分配长度不同的前缀码，以使得编码的总长度最小。

设计思想：

这里我们假设每个字符的出现次数 A：2，B：3，C：4，D：6

 哈夫曼树构建步骤如下：
找出最小的两个节点，这两个节点构成一个二叉树。然后把其根节点的值（即两数相加）加入到原来的队列中（原来队列中其他数不变，选中的最小的两个数去掉）。在新的队列中找出最小的两个节点，重复之前的操作，以此循环，直到队列中只有一个节点。

例如：

1.当前序列        A：2，B：3，C：4，D：6，最小值为2和3，即将A与B合并

2.当前序列        AB：5，C：4，D：6，最小值为4和5，即将C与AB合并

3.当前序列        ABC：9，D：6，最小值为6和9，即将D与ABC合并

4.此时已全部合并，添加01，规则为左0右1

字符	编码
A	110
B	111
C	10
D	0

关键代码：

void creatHuffmanTree(huffmanTree& HT, int n)    //构建哈夫曼树
{
	if (n <= 1)															//如果结点数小于等于1，不创建
		return;
	int min1, min2;														//定义两个数，来存储每次选取最小两个结点的权值
	int rnode, lnode;													//定义两个下标值，来存储每次选取最小两个结点的下标
	for (int i = n + 1; i <= 2 * n -1; i++)								//要生成n-1个结点，所以要操作n—1次且从下标为n+1开始存储
	{
		int min1 = MAXVALUE; int lnode = -1;							//让最小值初始化为极大值，这样叶子结点的最大值再大也不会超过这个值了							
		int min2 = MAXVALUE; int rnode = -1;
		for (int j = 1; j <= i - 1; j++)								//因为起先是在前n个中选择最小的两个结点的权值，但新生成一个后就得在前n+1个中选择最小的两个结点的权值							
		{																//假设n = 10 总结点数就得为19，那我们就只要比较18次就可以得出结果了，记住比较的次数比生成的总结点数少1
				if (HT[j].weight < min1 && HT[j].parent == -1)			//这个小于就使得当出现相同的权值时优先考虑先出现的值，可以假设下
				{
					min2 = min1;	rnode = lnode;						//碰到比min1小的，那min1的值就给第二小的min2，下标也给它
					min1 = HT[j].weight; lnode = j;						//然后最小的给min1，下标同理
				}
				else if (HT[j].weight < min2 && HT[j].parent == -1)		//这是第二小的判断
				{
					min2 = HT[j].weight;
					rnode = j;
				}
		}
		HT[lnode].parent = HT[rnode].parent = i;						//最小两个结点的parent变为生成结点的下标
		HT[i].lch = lnode; HT[i].rch = rnode;							//生成结点的左孩子为最小的min1的下标，右孩子同理
		HT[i].weight = HT[lnode].weight + HT[rnode].weight;				//生成结点的权值等于最小结点的权值相加
	}
		
}
 
void createHuffmanCode(huffmanTree HT, huffmanCode& HC, int n)    //编写哈夫曼编码
{
	HC = (huffmanCode)malloc(sizeof(huffmanCode) * n + 1);				//申请n + 1个huffmanCode大小huffmanCode类型的临时空间
																		//因为下标是从一开始，所以我们要申请比结点多一个的结点，和哈夫曼树的结构对应，方便输出
	char* cd = (char*)malloc(sizeof(char) * n);							//申请n个char大小char类型的临时空间，这个临时数组记录每次遍历出来的编码
	int start = 0,c = 0,f = 0;											//start为cd数组记录下标，c初始为叶子结点下标，而后就是孩子结点的下标，f记录双亲结点的下标
	cd[n - 1] = '\0';													//这个就是给printf留着的，因为printf不会生成'\0'，如果用puts就不用这句语句了
	for (int i = 1; i <= n; i++)										//只要叶子结点的编码
	{
		start = n - 1;													//这句要赋值n的话，start--要写在判断后方
		c = i;	
		f = HT[c].parent;
		while (f != -1)													//根节点没有双亲
		{
			start--;
			if (HT[f].lch == c)											//是左孩子就是0，右孩子就为1
				cd[start] = '0';
			else
				cd[start] = '1';
			c = f; f = HT[c].parent;									//向根结点接近
		}
		HC[i] = (char*)malloc(sizeof(char) * (n - start));				//给数组里的数组申请n - start个char大小的char*类型的临时空间
		strcpy(HC[i], &cd[start]);										//cd里记录的编码给HC的第i个数组
	}
	free(cd);															//释放临时空间
}