贪心算法之哈夫曼树哈夫曼编码 算法设计与分析

哈夫曼编码

一、【问题描述】
设要编码的字符集为{d1,d2,…,dn},它们出现的频率为{w1，w2，…,wn}，应用哈夫曼树构造最优的不等长的由0，1构成的编码方案。

二、【问题求解】
先构建以这个n个结点为叶子结点的哈夫曼树，然后由哈夫曼树产生各叶子结点对应字符的哈夫曼编码。

(0）哈夫曼树：给定n个权值作为n个叶子结点，构造一棵二叉树，若树的带权路径长度达到最小，则这棵树被称为哈夫曼树。

(1) 路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。

(2) 结点的权及带权路径长度：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。

(3) 树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL。

⭐对于一些基本概念，此处不进行更多赘述
如果还有疑惑可以参考这篇博文：
传送门→_→ 哈夫曼树+哈夫曼编码

构造一棵哈夫曼树的方法如下：
①由给定的n个权值， n个权值分别设为 w1、w2、…、wn，构造n棵只有1个叶子结点的二叉树，从而得到一个二叉树的集合F={T1,T2,…Tn}。

②在F中选取根节点的权值最小和次小的两颗二叉树作为左、右子树构造一棵新的二叉树，这颗新的二叉树根节点的权值为其左、右子树根节点权值之和。即合并两棵二叉树为一棵二叉树。

③重复步骤②，当F中只剩下一棵二叉树时，这棵二叉树便是所要建立的哈夫曼树。

例如给定a~d四个字符，它们的权值集合为w={100,10,50,20}

首先构造出哈夫曼树，过程如下图：


接下来对字符进行编码并求出WPL

三、【代码实现】
如下：

#pragma warning(disable:4786) //用于屏蔽标识符过长导致的warning 
#include <iostream>
#include <queue>
#include <vector>
#include <string>
#include <map>
using namespace std; 
#define MAX 101
int n;
struct HTreeNode				//哈夫曼树结点类型
{
	char data;					//字符
	int weight;					//权值
	int parent;					//双亲的位置
	int lchild;					//左孩子的位置
	int rchild;					//右孩子的位置
};
HTreeNode ht[MAX];				//哈夫曼树
map<char,string> htcode;			//哈夫曼编码

struct NodeType		//优先队列结点类型
{
	int no;				//对应哈夫曼树ht中的位置
	char data;			//字符
	int  weight;		//权值
	bool operator<(const NodeType &s) const
	{					//运算符重载进行从小到大的递增排序 
		return s.weight<weight;
	}
};
void CreateHTree()						//构造哈夫曼树
{
	NodeType e,e1,e2;
	priority_queue<NodeType> qu;
	for (int k=0;k<2*n-1;k++)	//设置所有结点的指针域
		ht[k].lchild=ht[k].rchild=ht[k].parent=-1;
	for (int i=0;i<n;i++)				//将n个结点进队qu
	{
		e.no=i;
		e.data=ht[i].data;
		e.weight=ht[i].weight;
		qu.push(e);
	}
	for (int j=n;j<2*n-1;j++)			//构造哈夫曼树的n-1个非叶结点
	{
		e1=qu.top();  qu.pop();		//出队权值最小的结点e1
		e2=qu.top();  qu.pop();		//出队权值次小的结点e2
		ht[j].weight=e1.weight+e2.weight; //构造哈夫曼树的非叶结点j	
		ht[j].lchild=e1.no;
		ht[j].rchild=e2.no;
		ht[e1.no].parent=j;			//修改e1.no的双亲为结点j
		ht[e2.no].parent=j;			//修改e2.no的双亲为结点j
		e.no=j;						//构造队列结点e
		e.weight=e1.weight+e2.weight;
		qu.push(e);
	}
}
void CreateHCode()			//构造哈夫曼编码
{
	string code;
	code.reserve(MAX);
	for (int i=0;i<n;i++)	//构造叶结点i的哈夫曼编码
	{
		code="";
		int curno=i;
		int f=ht[curno].parent;
		while (f!=-1)				//循环到根结点
		{
			if (ht[f].lchild==curno)	//curno为双亲f的左孩子
				code='0'+code;
			else					//curno为双亲f的右孩子
				code='1'+code;
			curno=f; f=ht[curno].parent;
		}
		htcode[ht[i].data]=code;	//得到ht[i].data字符的哈夫曼编码
	}
}
void DispHCode()					//输出哈夫曼编码
{
	map<char,string>::iterator it;
	for (it=htcode.begin();it!=htcode.end();++it)
		cout << "    " << it->first << ": " << it->second <<	endl;
}
void DispHTree()					//输出哈夫曼树
{
	for (int i=0;i<2*n-1;i++)
	{
		printf("    data=%c, weight=%d, lchild=%d, rchild=%d, parent=%d\n",
			ht[i].data,ht[i].weight,ht[i].lchild,ht[i].rchild,ht[i].parent);
	}
}
int WPL()				//求WPL
{
	int wps=0;
	for (int i=0;i<n;i++)
		wps+=ht[i].weight*htcode[ht[i].data].size();
	return wps;
}

int main()
{
	n=4;
	ht[0].data='a'; ht[0].weight=100;		//置初值即n个叶子结点
	ht[1].data='b'; ht[1].weight=10;  
	ht[2].data='c'; ht[2].weight=50;  
	ht[3].data='d'; ht[3].weight=20;  
	CreateHTree();					//建立哈夫曼树
	printf("构造的哈夫曼树:\n");
	DispHTree();
	CreateHCode();					//求哈夫曼编码
	printf("产生的哈夫曼编码如下:\n");
	DispHCode();					//输出哈夫曼编码
	printf("WPL=%d\n",WPL());
	return 0;
}

代码运行截图：

本文参考自《算法设计与分析》李春葆第二版