哈夫曼树

二叉树的带权路径长度

设二叉树具有n个带权值的叶子结点，从根结点到各个叶子结点的路径长度与相应叶子结点权值的乘积之和。记为

在这些由不同的路径组成的树中，带权路径长度最小的二叉树，称之为哈夫曼树，也称作最优二叉树。

哈夫曼树的特点

• 权值越大的叶子结点越靠近根结点，而权值越小的叶子结点越远离根结点（构造的核心思想）
• n个叶结点的哈夫曼树的结点总数为2n-1个
• 哈夫曼树不唯一，但WPL唯一

哈夫曼树的构造

步骤

• 由给定的n个权值{w1，w2，…，wn}构造n棵只有一个根结点、左右子树均空的二叉树，从而得到一个二叉树集合F＝{T1，T2，…，Tn}
• 在F中选取根结点的权值最小的两棵二叉树分别作为左、右子树构造一棵新的二叉树，这棵新二叉树的根结点的权值为其左、右子树根结点的权值之和
• 在F中删除作为左、右子树的两棵二叉树，并将新建立的二叉树加入到F中
• 重复⑵、⑶两步，当集合F中只剩下一棵二叉树时，这棵二叉树便是哈夫曼树

例如：W={2，3，4，11}
得到：

再之后，我们有：

最后我们可以得到：

代码实现

初始化

在我们创建哈夫曼树之前，我们要先定义他的数据结构，由权重、左孩子、右孩子和父节点构成，并且我们把哈夫曼树除输入的权重之外的部分初始化为1，如下图所示：

struct HTNode
{
	double weight;
	int lchild;
	int rchild;
	int parent;
};
typedef HTNode* HuffmanTree;

构建

在初始化之后，我们需要做的即为逐渐找到最小的两个结点，并将他们构成一个父节点，就像上面做的那样，并重复这个过程。我们可以逐渐得到：

经过这样的几步之后，我们可以得到：

这样，一个完整的哈夫曼树就建立起来了。

代码

/*哈夫曼树实现
**HIT Visual Lab
**2019.03.03下午*/

#include "stdafx.h"
#include 

#define maxSize 7

using namespace std;

struct HTNode
{
	double weight;
	int lchild;
	int rchild;
	int parent;
};
typedef HTNode* HuffmanTree;

HuffmanTree ini_tree(HuffmanTree T);
void display(HuffmanTree T);
void CreatHT(HuffmanTree T);
void FindMin(HuffmanTree T, int position, int* num_1, int* num_2);

int main()
{
	HuffmanTree T = NULL;
	T = ini_tree(T);
	display(T);
	CreatHT(T);
	return 0;
}

//哈夫曼树的初始化
HuffmanTree ini_tree(HuffmanTree T)
{
	if (maxSize % 2 == 0)
	{
		cout << "请分配奇数的内存" << endl;
		exit(-1);
	}
	else
	{
		double num = 0;
		T = (HuffmanTree)malloc(maxSize * sizeof(HTNode));
		for (int i = 0; i < (maxSize + 1) / 2; i++)
		{
			cin >> num;
			T[i].weight = num;
			T[i].lchild = -1;
			T[i].rchild = -1;
			T[i].parent = -1;
		}
		for (int i = (maxSize + 1) / 2; i < maxSize; i++)
		{
			T[i].weight = -1;
			T[i].lchild = -1;
			T[i].rchild = -1;
			T[i].parent = -1;
		}
		return T;
	}
}

//展示哈夫曼树
void display(HuffmanTree T)
{
	for (int i = 0; i < maxSize; i++)
	{
		cout << T[i].weight << " ";
	}
	cout << endl;
}

//根据初始化创建完整的树
void CreatHT(HuffmanTree T)
{
	int p1(0), p2(0);
	for (int i = (maxSize + 1) / 2; i < maxSize; i++)
	{
		FindMin(T, i, &p1, &p2);
		cout << p1 << " " << p2 << endl;
		T[p1].parent = i;
		T[p2].parent = i;
		T[i].weight = T[p1].weight + T[p2].weight;
		T[i].lchild = p1;
		T[i].rchild = p2;
	}
}

//找到目前树中最小的两个结点（但不算之前找过的）
void FindMin(HuffmanTree T, int position, int* num_1, int* num_2)
{
	int n1 = 65535, n2 = 65535;
	*num_1 = 0;
	*num_2 = 1;
	for (int i = 0; i < position; i++)
	{
		//之前找过的不能算
		if (T[i].parent == -1)
		{
			//比现在小的就是较小的
			if (T[i].weight <= n1 || T[i].weight <= n2)
				if (n1 <= n2)
				{
					n2 = T[i].weight;
					*num_2 = i;
				}
				else
				{
					n1 = T[i].weight;
					*num_1 = i;
				}
					
		}
	}
}

本篇博客参考哈工大数据结构课件，图部分源自其中，侵权请联系
代码完全原创