哈夫曼编解码原理与实现【转载】

1. 哈夫曼编解码原理
霍夫曼编码(Huffman Coding)是一种编码方法，霍夫曼编码是可变字长编码(VLC)的一种。

霍夫曼编码使用变长编码表对源符号（如文件中的一个字母）进行编码，其中变长编码表是通过一种评估来源符号出现机率的方法得到的，出现机率高的字母使用较短的编码，反之出现机率低的则使用较长的编码，这便使编码之后的字符串的平均长度、期望值降低，从而达到无损压缩数据的目的。

霍夫曼编码的具体步骤如下：

1. 将信源符号的概率按减小的顺序排队。
2. 把两个最小的概率相加，并继续这一步骤，始终将较高的概率分支放在右边，直到最后变成概率１。
3. 画出由概率１处到每个信源符号的路径，顺序记下沿路径的０和１，所得就是该符号的霍夫曼码字。
4. 将每对组合的左边一个指定为0，右边一个指定为1（或相反）。

例：现有一个由5个不同符号组成的30个符号的字符串：

BABACAC ADADABB CBABEBE DDABEEEBB

• 首先计算出每个字符出现的次数（概率）：

字符	次数
B	10
A	8
C	3
D	4
E	5

• 把出现次数（概率）最小的两个相加，并作为左右子树，重复此过程，直到概率值为1
  
  第一次：将概率最低值3和4相加，组合成7：
  
  第二次：将最低值5和7相加，组合成12：
  
  第三次：将8和10相加，组合成18：
  
  第四次：将最低值12和18相加，结束组合：
  
• 将每个二叉树的左边指定为0，右边指定为1。
  
• 沿二叉树顶部到每个字符路径，获得每个符号的编码。

字符	次数	编码
B	10	11
A	8	10
C	3	010
D	4	011
E	5	00

我们可以看到出现次数（概率）越多的会越在上层，编码也越短，出现频率越少的就越在下层，编码也越长。当我们编码的时候，我们是按“bit”来编码的，解码也是通过bit来完成，如果我们有这样的bitset “10111101100″ 那么其解码后就是 “ABBDE”。所以，我们需要通过这个二叉树建立我们Huffman编码和解码的字典表。

这里需要注意的是，Huffman编码使得每一个字符的编码都与另一个字符编码的前一部分不同，不会出现像’A’：00， ’B’：001，这样的情况，解码也不会出现冲突。

霍夫曼编码的局限性
利用霍夫曼编码，每个符号的编码长度只能为整数，所以如果源符号集的概率分布不是2负n次方的形式，则无法达到熵极限；输入符号数受限于可实现的码表尺寸；译码复杂；需要实现知道输入符号集的概率分布；没有错误保护功能。

2.哈夫曼编解码实现（C++）

#include<iostream>  
#include<string>  
using namespace std;

struct Node
{
	double weight;
	string ch;
	string code;
	int lchild, rchild, parent;
};

void Select(Node huffTree[], int *a, int *b, int n)//找权值最小的两个a和b，且无父节点的两个节点合并
{
	int i;
	double weight = 0; //找最小的数
	for (i = 0; i < n; i++)
	{
		if (huffTree[i].parent != -1)     //判断节点是否已经选过
			continue;
		else
		{
			if (weight == 0)
			{
				weight = huffTree[i].weight;
				*a = i;
			}
			else
			{
				if (huffTree[i].weight < weight)
				{
					weight = huffTree[i].weight;
					*a = i;
				}
			}
		}
	}

	weight = 0; //找第二小的数
	for (i = 0; i < n; i++)
	{
		if (huffTree[i].parent != -1 || (i == *a))//排除已选过的数
			continue;
		else
		{
			if (weight == 0)
			{
				weight = huffTree[i].weight;
				*b = i;
			}
			else
			{
				if (huffTree[i].weight < weight)
				{
					weight = huffTree[i].weight;
					*b = i;
				}
			}
		}
	}

	//int temp;
	//if (huffTree[*a].weight > huffTree[*b].weight)  //小的数放左边
	//{
	//	temp = *a;
	//	*a = *b;
	//	*b = temp;
	//}
}

void Huff_Tree(Node huffTree[], int w[], string ch[], int n)
{
	//初始过程 2倍的节点数
	for (int i = 0; i < 2 * n - 1; i++) 
	{
		huffTree[i].parent = -1;
		huffTree[i].lchild = -1;
		huffTree[i].rchild = -1;
		huffTree[i].code = "";
	}
	for (int i = 0; i < n; i++)
	{
		huffTree[i].weight = w[i];
		huffTree[i].ch = ch[i];
	}

	//构建哈夫曼树
	for (int k = n; k < 2 * n - 1; k++)
	{
		int i1 = 0;
		int i2 = 0;
		Select(huffTree, &i1, &i2, k); //将i1，i2节点合成节点k
		huffTree[i1].parent = k;
		huffTree[i2].parent = k;
		huffTree[k].weight = huffTree[i1].weight + huffTree[i2].weight;
		huffTree[k].lchild = i1;
		huffTree[k].rchild = i2;
	}
}

void Huff_Code(Node huffTree[], int n)
{
	int i, j, k;
	string s = "";
	for (i = 0; i < n; i++)
	{
		s = "";
		j = i;
		while (huffTree[j].parent != -1) //从叶子往上找到根节点
		{
			k = huffTree[j].parent;
			if (j == huffTree[k].lchild) //如果是根的左孩子，则记为0
			{
				s = s + "0";
			}
			else
			{
				s = s + "1";
			}
			j = huffTree[j].parent;
		}
		cout << "字符 " << huffTree[i].ch << " 的编码：";
		for (int l = s.size() - 1; l >= 0; l--)
		{
			cout << s[l];
			huffTree[i].code += s[l]; //保存编码
		}
		cout << endl;
	}
}

string Huff_Decode(Node huffTree[], int n, string s)
{
	cout << "解码后为：";
	string temp = "", str = "";//保存解码后的字符串
	for (int i = 0; i < s.size(); i++)
	{
		temp = temp + s[i];
		for (int j = 0; j < n; j++)
		{
			if (temp == huffTree[j].code)
			{
				str = str + huffTree[j].ch;
				temp = "";
				break;
			}
			else if (i == s.size() - 1 && j == n - 1 && temp != "")//全部遍历后没有
			{
				str = "解码错误！";
			}
		}
	}
	return str;
}

int main()
{
	//编码过程
	const int n = 5;
	Node huffTree[2 * n];
	string str[] = { "A", "B", "C", "D", "E" };
	int w[] = { 8, 10, 3, 4, 5 };
	Huff_Tree(huffTree, w, str, n);
	Huff_Code(huffTree, n);
	//解码过程
	string s;
	cout << "输入编码：";
	cin >> s;
	cout << Huff_Decode(huffTree, n, s) << endl;;
	system("pause");
	return 0;
}

结果：

---

以上博文整理自：

1. 理论部分：https://www.cnblogs.com/gyk666/p/6851821.html
2. 实现部分：https://blog.csdn.net/xgf415/article/details/52628073