赫夫曼树及赫夫曼代码讲解

赫夫曼树及赫夫曼代码讲解

1、赫夫曼树讲解

赫夫曼树（Huffman Tree），又称最优二叉树，是一类带权路径长度最短的树，当用 n 个结点（都做叶子结点且都有各自的权值）试图构建一棵树时，如果构建的这棵树的带权路径长度最小，称这棵树为“最优二叉树”，有时也叫“赫夫曼树”或者“哈夫曼树”。

赫夫曼树，我举一个最简单的例子，也就是如果5个英文字母，
统计一下，分别出现次数 A:100 B:20 C:60 D:2 E:23,这五
个字母A出现最多，D最少，那么我们在使用过程中肯定用A最多，
所以就将A放在最接近跟节点的地方，最少的D放在最远的地方。
这样的话就大大节省了我们在取用过程花费的时间。

首先了解几个赫夫曼树的名词。
路径：在一棵树中，一个结点到另一个结点之间的通路，称为路径。图中，从根结点到结点 a 之间的通路就是一条路径。

路径长度：在一条路径中，每经过一个结点，路径长度都要加 1 。例如在一棵树中，规定根结点所在层数为1层，那么从根结点到第 i 层结点的路径长度为 i - 1 。图 1 中从根结点到结点 c 的路径长度为 3。

结点的权：给每一个结点赋予一个新的数值，被称为这个结点的权。例如，图中结点 a 的权为 7，结点 b 的权为 5。

结点的带权路径长度：指的是从根结点到该结点之间的路径长度与该结点的权的乘积。如图结点 b 的带权路径长度为 2 * 5 = 10 。

2、赫夫曼树如何生成

例如现在有如下几个字母，权值分别为：
A:90, B:50, C:40， D:100， E:14， F:7， G:2

• 第一步
  找出权值最小的两个，组成二叉树
  
• 去除F、G，添加9，重复第一步
  现在在剩下的A:90, B:50, C:40， D:100， E:14 ，9这几个数字中找出两个最小的组成二叉树。
  
• 重复上面操作，在A:90, B:50, C:40， D:100 ， 23中找出最小的两个组成二叉树。
  
• 重复上面操作，在A:90, B:50, D:100 ，63中找出两个最小的组成二叉树。
  
• 重复上面操作。在A:90, D:100 ，113中选择两个最小的组成二叉树。
  
• 现在只有两个点了。
  
  这就是生成过程，应该大家都能看懂，

3、代码实现

#include<iostream>
#define maxSize 100
#include <cstring>
using namespace std;
//节点的属性
typedef struct Node
{
    
    
	int weight;                //权值
	int parent;                //下面会首先初始化所有节点父节点为-1，代表还没有加入树中，如果后面对节点进行复制，父节点就不会等于-1了。
	int lchild, rchild;         //左右孩子节点的序号
}HTNode, *HuffmanTree;          //用来存储赫夫曼树中的所有节点
typedef char **HuffmanCode;    //用来存储每个叶子节点的赫夫曼编码

HuffmanTree create_HuffmanTree(int *wet, int n);
void select_minium(HuffmanTree HT, int k, int &min1, int &min2);
int min(HuffmanTree HT, int k);
void HuffmanCoding2(HuffmanTree HT, HuffmanCode &HC, int n);
int countWPL2(HuffmanTree HT, int n);
int main()
{
    
    
    int         n;
    int         num;
    cout << "please input how many num:";
    cin >> n;
    int        w[n];
    for(int i; i<n ;i++){
    
    
        cout << "please input " << i << ":";
        cin >> num;
        w[i] = num;
    }


	HuffmanCode HC = NULL;
	HuffmanTree hTree = create_HuffmanTree(w, n);


	int wpl2 = countWPL2(hTree, n);
	printf("从根结点开始遍历二叉树求最小带权路径长度WPL=%d\n", wpl2);


	printf("\n从根结点到叶子结点编码结果为：\n");
	HuffmanCoding2(hTree, HC, n);
	system("pause");
	return 0;
}

//创建树
HuffmanTree create_HuffmanTree(int *wet, int n)
{
    
    
	//一棵有n个叶子节点的赫夫曼树共有2n-1个节点
	int total = 2 * n - 1;
	HuffmanTree HT = (HuffmanTree)malloc(total * sizeof(HTNode));
	if (!HT)
	{
    
    
		printf("HuffmanTree malloc faild!");
		exit(-1);
	}
	int i;


    /*首先将所有节点的父节点赋值为-1.代表还没有加入树中
	HT[0],HT[1]...HT[n-1]中存放需要编码的n个叶子节点，叶子节点都是带权的*/
	
	for (i = 0; i < n; i++)
	{
    
    
		HT[i].parent = -1;
		HT[i].lchild = -1;
		HT[i].rchild = -1;
		HT[i].weight = *wet;
		wet++;
	}


	//初始化不带权值的节点，HT[n],HT[n+1]...HT[2n-2]中存放的是中间构造出的每棵二叉树的根节点
	for (; i < total; i++)
	{
    
    
		HT[i].parent = -1;
		HT[i].lchild = -1;
		HT[i].rchild = -1;
		HT[i].weight = 0;
	}

	int min1, min2;
    //用来保存每一轮选出的两个weight最小且parent为-1的节点
    //每一轮比较后选择出min1和min2构成一课二叉树,最后构成一棵赫夫曼树
	for (i = n; i < total; i++)
	{
    
    
	    //传入的参数，第一个是树指针，第二个是构造的节点的第一个数
		select_minium(HT, i, min1, min2);
		HT[min1].parent = i;
		HT[min2].parent = i;
		//这里左孩子和右孩子可以反过来，构成的也是一棵赫夫曼树，只是所得的编码不同
		HT[i].lchild = min1;
		HT[i].rchild = min2;
		HT[i].weight = HT[min1].weight + HT[min2].weight;
	}
	return HT;
}
/*
从HT数组的前k个元素中选出weight最小且parent为-1的两个，分别将其序号保存在min1和min2中
*/
void select_minium(HuffmanTree HT, int k, int &min1, int &min2)
{
    
    
	min1 = min(HT, k);
	min2 = min(HT, k);
}
/*
从HT数组的前k个元素中选出weight最小且parent为-1的元素，并将该元素的序号返回
*/
int min(HuffmanTree HT, int k)
{
    
    
	int i = 0;
	int min;        //用来存放weight最小且parent为-1的元素的序号
	int min_weight; //用来存放weight最小且parent为-1的元素的weight值

    //先将第一个parent为-1的元素的weight值赋给min_weight,留作以后比较用。
    //注意，这里不能按照一般的做法，先直接将HT[0].weight赋给min_weight，
    //因为如果HT[0].weight的值比较小，那么在第一次构造二叉树时就会被选走，
    //而后续的每一轮选择最小权值构造二叉树的比较还是先用HT[0].weight的值来进行判断，
    //这样又会再次将其选走，从而产生逻辑上的错误。
    //这里先找出还没有加入树中带权值的节点。
	while (HT[i].parent != -1)
		i++;
	min_weight = HT[i].weight; //找到之后将他的权值赋值给变量
	min = i;

	//选出weight最小且parent为-1的元素，并将其序号赋给min
	for (; i < k; i++)
	{
    
    
		if (HT[i].weight < min_weight && HT[i].parent == -1)
		{
    
    
			min_weight = HT[i].weight;
			min = i;
		}
	}

	//选出weight最小的元素后，将其parent置1，使得下一次比较时将其排除在外。
	HT[min].parent = 1;

	return min;
}

/*
从根节点到叶子节点无栈非递归遍历赫夫曼树HT，求其中n个叶子节点的赫夫曼编码，并保存在HC中
*/
void HuffmanCoding2(HuffmanTree HT, HuffmanCode &HC, int n)
{
    
    
	//用来保存指向每个赫夫曼编码串的指针
	HC = (HuffmanCode)malloc(n * sizeof(char *));
	if (!HC)
	{
    
    
		printf("HuffmanCode malloc faild!");
		exit(-1);
	}

	//临时空间，用来保存每次求得的赫夫曼编码串
	//对于有n个叶子节点的赫夫曼树，各叶子节点的编码长度最长不超过n-1
	//外加一个'\0'结束符，因此分配的数组长度最长为n即可
	char *code = (char *)malloc(n * sizeof(char));
	if (!code)
	{
    
    
		printf("code malloc faild!");
		exit(-1);
	}

	int cur = 2 * n - 2;    //当前遍历到的节点的序号，初始时为根节点序号
	int code_len = 0;   //定义编码的长度

//构建好赫夫曼树后，把weight用来当做遍历树时每个节点的状态标志
//weight=0表明当前节点的左右孩子都还没有被遍历
//weight=1表示当前节点的左孩子已经被遍历过，右孩子尚未被遍历
//weight=2表示当前节点的左右孩子均被遍历过
	int i;
	for (i = 0; i < cur + 1; i++)
	{
    
    
		HT[i].weight = 0;
	}

	//从根节点开始遍历，最后回到根节点结束
	//当cur为根节点的parent时，退出循环
	while (cur != -1)
	{
    
    
		//左右孩子均未被遍历，先向左遍历
		if (HT[cur].weight == 0)
		{
    
    
			HT[cur].weight = 1;    //表明其左孩子已经被遍历过了
			if (HT[cur].lchild != -1)
			{
    
       //如果当前节点不是叶子节点，则记下编码，并继续向左遍历
				code[code_len++] = '0';
				cur = HT[cur].lchild;
			}
			else
			{
    
       //如果当前节点是叶子节点，则终止编码，并将其保存起来
				code[code_len] = '\0';
				HC[cur] = (char *)malloc((code_len + 1) * sizeof(char));
				if (!HC[cur])
				{
    
    
					printf("HC[cur] malloc faild!");
					exit(-1);
				}
				strcpy(HC[cur], code);  //复制编码串
			}
		}

		//左孩子已被遍历，开始向右遍历右孩子
		else if (HT[cur].weight == 1)
		{
    
    
			HT[cur].weight = 2;   //表明其左右孩子均被遍历过了
			if (HT[cur].rchild != -1)
			{
    
       //如果当前节点不是叶子节点，则记下编码，并继续向右遍历
				code[code_len++] = '1';
				cur = HT[cur].rchild;
			}
		}

		//左右孩子均已被遍历，退回到父节点，同时编码长度减1
		else
		{
    
    
			HT[cur].weight = 0;
			cur = HT[cur].parent;
			--code_len;
		}

	}
	for (int i = 0; i < n; ++i) {
    
    
		printf("%s\n", HC[i]);
	}
	free(code);
}

/*
以下是从根结点开始遍历二叉树，求最小带权路径长度。关键步骤是求出各个叶子
结点的路径长度，用此路径长度*此结点的权值就是此结点带权路径长度，最后将
各个叶子结点的带权路径长度加起来即可。
*/
int countWPL2(HuffmanTree HT, int n)
{
    
    
	int cur = 2 * n - 2;    //当前遍历到的节点的序号，初始时为根节点序号
	int countRoads=0, WPL=0;//countRoads保存叶子结点的路径长度

//构建好赫夫曼树后，把visit[]用来当做遍历树时每个节点的状态标志
//visit[cur]=0表明当前节点的左右孩子都还没有被遍历
//visit[cur]=1表示当前节点的左孩子已经被遍历过，右孩子尚未被遍历
//visit[cur]=2表示当前节点的左右孩子均被遍历过
	int visit[maxSize] = {
    
     0 };//visit[]是标注数组,初始化为0

	//从根节点开始遍历，最后回到根节点结束
	//当cur为根节点的parent时，退出循环
	while (cur != -1)
	{
    
    
		//左右孩子均未被遍历，先向左遍历
		if (visit[cur]==0)
		{
    
    
			visit[cur] = 1;    //表明其左孩子已经被遍历过了
			if (HT[cur].lchild != -1)
			{
    
       //如果当前节点不是叶子节点，则路径长度+1，并继续向左遍历
				countRoads++;
				cur = HT[cur].lchild;
			}
			else
			{
    
       //如果当前节点是叶子节点，则计算此结点的带权路径长度，并将其保存起来
				WPL += countRoads * HT[cur].weight;
			}
		}

		//左孩子已被遍历，开始向右遍历右孩子
		else if (visit[cur]==1)
		{
    
    
			visit[cur] = 2;
			if (HT[cur].rchild != -1)
			{
    
       //如果当前节点不是叶子节点，则记下编码，并继续向右遍历
				countRoads++;
				cur = HT[cur].rchild;
			}
		}

		//左右孩子均已被遍历，退回到父节点，同时路径长度-1
		else
		{
    
    
			visit[cur] = 0;
			cur = HT[cur].parent;
			--countRoads;
		}

	}
	return WPL;
}