Huffman 编码 C++实现

大约十年前就该完成的程序，今天才搞定了，花了两个小时，直接看《算法引论-一种创造性方法》第6章 Haffman 编码的方法 和 第四章 堆 的实现， 书上给的是最大堆， Huffman 编码 需要用最小堆， 使用数组实现堆， 如果起始坐标从0开始带来一些麻烦，书上给的伪代码是从1 开始。

之所以说十年前，是因为大三的时候，信息论的课上肯定是讲了这个算法的， 算法本身很直观，思想简洁，但编码实现也要非一番功夫，一些细节处理，比如堆。 然后就是 把 二进制编码输出来， 只输出叶节点信息。这里面涉及了 二叉树 和 堆 两种数据结构。

#include <iostream>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <unordered_map> 
#include <algorithm> 


using namespace std;

struct TreeNode {
	char c;  // 对应的编码字符，可能不存在，此时设为0

	TreeNode *left;
	TreeNode *right;
	TreeNode(char x) : c(x), left(NULL), right(NULL) {}

};

struct HCHAR
{
	char c; // 编码字符
	int n; // 频率
	
	TreeNode *node; // 对应的树节点， 编码时用，实现 堆功能时 不需要

	HCHAR(char _c, int _n) :c(_c), n(_n) {}
};

// 使用 vector来实现堆操作,huffman 编译使用最小堆 
void insert_to_heap(vector<HCHAR> & heap, HCHAR hc)
{
	heap.push_back(hc);

	int len = heap.size();

	auto childIdx = len - 1;
	auto parentIdx = (childIdx - 1) / 2;

	while (parentIdx >= 0)
	{
		// 最小堆的情况下，如果当前子节点大于父节点，那么交换数据
		if (heap[parentIdx].n > heap[childIdx].n)
		{
			auto t = heap[parentIdx];
			heap[parentIdx] = heap[childIdx];
			heap[childIdx] = t;

			childIdx = parentIdx;
			parentIdx = (childIdx - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

HCHAR remove_min_from_heap(vector<HCHAR> & heap)
{
	if (heap.empty())
	{
		return HCHAR('0',-1);
	}

	auto res = heap[0];

	heap[0] = heap.back();
	heap.pop_back();

	int len = heap.size();

	auto parentIdx = 0;
	auto childIdx = 1;;

	while (childIdx <= len - 1)
	{
		if ((childIdx != len-1) && (heap[childIdx].n > heap[childIdx+1].n))
		{
			childIdx = childIdx + 1;
		}
		else {}

		// 最小堆， 如果父节点大于 子节点，那么交换数据
		if (heap[childIdx].n < heap[parentIdx].n)
		{
			auto t = heap[parentIdx];
			heap[parentIdx] = heap[childIdx];
			heap[childIdx] = t;

			parentIdx = childIdx;
			childIdx = 2 * childIdx + 1;
		}
		else
		{
			break;
		}
	}
	return res;
}

// 假设所有字符已经插入到 最小堆中
TreeNode * Huffman_Encoding(vector<HCHAR> & heap)
{
	while (!heap.empty())
	{
		// TODO : 考虑heap中本身只有一个元素的情况
		if (heap.size() == 1)
		{
			return heap[0].node;
		}
		else
		{
			auto x = remove_min_from_heap(heap);
			auto y = remove_min_from_heap(heap);

			TreeNode * left;

			// 混合节点就使用之前new出的节点
			if (x.c != 0)
			{
				left = new TreeNode(x.c);
			}
			else
			{
				left = x.node;
			}

			TreeNode * right;
			if (y.c != 0)
			{
				right = new TreeNode(y.c);
			}
			else
			{
				right = y.node;
			}

			TreeNode * z = new TreeNode(0);
			z->left = left;
			z->right = right;

			HCHAR hc(0, x.n + y.n);
			hc.node = z;

			insert_to_heap(heap, hc);
		}
	}

	return heap[0].node;;
}

void outputHeap(vector<HCHAR> & heap)
{
	for (auto x : heap)
	{
		std::cout << x.c << " " << x.n << std::endl;
	}
}

// 由浅入深 输出 叶子节点
void outputHuffmanTree(TreeNode * root)
{
	queue<TreeNode *> que;
	que.push(root);

	while (!que.empty())
	{
		auto head = que.front();
		que.pop();

		if (head->c != 0)
		{
			std::cout << head->c << std::endl;
		} else
		{ }

		if (head->left != NULL)
		{
			que.push(head->left);
		}
		if (head->right != NULL)
		{
			que.push(head->right);
		}
	}
}

void outputHuffmanTreeBinary(TreeNode * root, string prefix)
{
	if (root->left == NULL && root->right == NULL)
	{
		std::cout << root->c << " " << prefix.c_str() << std::endl;
	}
	else
	{
		outputHuffmanTreeBinary(root->left, prefix + "0");
		outputHuffmanTreeBinary(root->right, prefix + "1");
	}
}
// 中序遍历
void outputHuffmanTreeBinary(TreeNode * root)
{
	if (root != NULL)
	{
		outputHuffmanTreeBinary(root->left, "0");

		outputHuffmanTreeBinary(root->right, "1");
	}
}

int main()
{
	vector<HCHAR> heap;

	vector<pair<char, int>> ci = {
		{'A', 5},
		{'B', 2},
		{'C', 3},
		{'D', 4},
		{'E', 10},
		{'F', 1},
	};

	for (auto x : ci)
	{
		HCHAR hc(x.first, x.second);
		insert_to_heap(heap, hc);
	}

	outputHeap(heap);

	//auto res = remove_min_from_heap(heap);
	//std::cout << res.c << std::endl;

	//outputHeap(heap);
	std::cout << "------------------huffman prefix code------------------" << std::endl;
	auto root = Huffman_Encoding(heap);
	//outputHuffmanTree(root);

	outputHuffmanTreeBinary(root);

	return 0;
}

程序输出效果如下

F 1
D 4
B 2
A 5
E 10
C 3
------------------huffman prefix code------------------
E 0
C 100
F 1010
B 1011
D 110
A 111

David Albert Huffman 生平 — 出自维基百科

1944年，在俄亥俄州立大学取得电机工程学士。在第二次世界大战期间，进入美国海军，服役两年。退伍后，他回到俄亥俄州立大学，取得电机工程硕士。其后进入麻省理工学院攻读博士，主修电机工程。1953年，取得自然科学博士。在攻读博士期间，于1952年发表了霍夫曼编码。
在取得博士学位后，他成为麻省理工学院教师。1967年，转至圣塔克鲁兹加利福尼亚大学任教，在此，他协助创立了计算机科学系，1970年至1973年间，他担任系主任。1994年，他从学校退休。
1999年，被诊断出癌症，在同年10月病逝。享年74岁。