哈夫曼树的实现

介绍

哈夫曼树：WPL最小的树

• 节点的路径长度：

A节点到B节点之间所经过的分支数

• 树的路径长度：

根节点到各个节点所经过的分支数之和（TL）。其中在节点数相同的二叉树中，完全二叉树的TL最短

• 权：

对一个节点赋予一定的值

• 带权路径长度：

节点到根的路径长度乘以该节点的权值

• 树的带权路径长度：

所有叶子节点的带权路径长度之和（WPL）。哈夫曼树权值越大的叶子里根的路径越短

哈夫曼算法：

1. 首先创建一个森林，每棵树都是一个带权值的根节点
2. 将根节点权值最小的两个树作为左右子树构造一个新的树，并将左右子树权值之和作为自身根节点权值
3. 重复上一条直到只剩一棵树

    【注】若已知n个节点，则哈夫曼树共有2n-1个节点，且每个节点度数为0或2

实现：

/*采用顺序表来存储哈夫曼树每个节点*/
typedef struct {
	int weight;
	int parent, lch, rch;
}HtNode, * HuffmanTree;
/*寻找最小的两个权值*/
void Search(HuffmanTree H, int n, int* s1, int* s2) {
	int k = 0;
	int* arr = (int*)malloc(sizeof(int) * n);//首先将亲节点为空的节点下标存入数组中
	for (int i = 0; i < n; i++) {
		if (!H[i].parent) 
			arr[k++] = i;
	}
	*s1 = arr[0];//先将s1，s2随便取两个不同的下标
	*s2 = arr[1];
	int tmp = H[arr[0]].weight;//临时变量存储对应s1下标的节点的权值
	for (int i = 1; i < k - 1; i++) {//对数组中进行遍历
		if (arr[i] != (*s2)) {//在寻找最小下标s1时首先去除数组中s2的值，防止s1和s2产生相同结果
			if (tmp > H[arr[i]].weight) {//将临时变量与剩下的节点权值分别比较
				tmp = H[arr[i]].weight;//若比较结果是临时变量大于该节点权值，则将临时变量换做该节点的权值并将s1的值取该节点下标，以保证s1对应节点权值是最小的
				*s1 = arr[i];
			}
		}
	}
	tmp = H[arr[1]].weight;
	for (int i = 0; i < k - 1; i++) {
		if (arr[i] != (*s1)) {
			if (tmp > H[arr[i]].weight) {
				tmp = H[arr[i]].weight;
				*s2 = arr[i];
			}
		}
	}
}
/*创建哈夫曼树顺序表*/
HuffmanTree Creat(int n) {
	if (n <= 1)
		return NULL;
	HuffmanTree H = (HuffmanTree)malloc(sizeof(HtNode) * (2 * n - 1));
	for (int i = 0; i < 2 * n - 1; i++) {
		H[i].lch = H[i].rch = H[i].parent = 0;
	}
	int weight;
	for (int i = 0; i < n; i++) {
		scanf("%d", &weight);
		getchar();
		H[i].weight = weight;
	}		
	int s1, s2;
	for (int i = n; i < 2 * n - 1; i++) {
		Search(H, i, &s1, &s2);
		H[s1].parent = H[s2].parent = i;
		H[i].lch = s1;
		H[i].rch = s2;
		H[i].weight = H[s1].weight + H[s2].weight;
		printf("\ns1=%d,s2=%d,H[%d].weight=%d\n", s1, s2, i, H[i].weight);
	}
	return H;
}

效果：

若选择八个根节点来构造哈夫曼树，并输入八个权值分别为

5，29，7，8，14，23，3，11

输出结果如下