C++实现哈夫曼编码--使用哈夫曼编码树压缩和解压缩

      压缩就是位域的操作，假设A对应0000，B对应1111，则AB压缩后为00001111即为0x0F，AB原本为2个字节，压缩后变为1个字节。其它数据类似一样的压缩操作即可。

      解压缩就是取出每一个位，如果是0，则走到哈夫曼编码树的左孩子，如果是1，则走到哈夫曼编码树的右孩子，接着判断是否走到了叶子节点，如果是，输出叶子节点对应的编码值即可。依次类推，解压出全部数据。

      如下的代码只是为了更好的演示压缩和解压过程，基本没有太多考虑效率等问题。

      

#ifndef _HANFUMAN_H_
#define _HANFUMAN_H_

typedef struct _t_HANFUMAN_TREE
{
	unsigned char data;    //编码的数据值，0-255之间,如果不是叶子节点，设置为0
	unsigned short weight; //编码数字的权重,可以是出现的概率，这里使用data出现的次数

	_t_HANFUMAN_TREE* parent;
	_t_HANFUMAN_TREE* left;
	_t_HANFUMAN_TREE* right;
}HANFUMAN_TREE,*PHANFUMAN_TREE;

#define MAX_CODE_BYTES 16

#define INDEX_TYPE_TREE 0x00
#define INDEX_TYPE_INFO 0x01

typedef struct _t_HANFUMAN_SELECT_HELPER
{
	_t_HANFUMAN_SELECT_HELPER()
	{
		Init();
	}
	void Init()
	{
		firstMinIndex = -1;
		secondMinIndex = -1;
		firstMinType = INDEX_TYPE_TREE; //默认值为子树类型
		secondMinType = INDEX_TYPE_TREE; //默认值为子树类型
	}
	int firstMinIndex; 
	int secondMinIndex;
	unsigned char firstMinType;
	unsigned char secondMinType;
}HANFUMAN_SELECT_HELPER,*PHANFUMAN_SELECT_HELPER;

typedef struct _t_DATA_INFO
{
	unsigned char data;  
	unsigned short times; //data出现的次数
}DATA_INFO,*PDATA_INFO;

typedef struct _t_HANFUMAN_CODE_ITEM
{
	unsigned char data[MAX_CODE_BYTES]; //最长表示MAX_CODE_BYTES*8长度的编码位域  
	unsigned short codeLen;//编码的位域长度
}HANFUMAN_CODE_ITEM,*PHANFUMAN_CODE_ITEM;

BOOL TestHanfuMan();

//创建哈夫曼编码树
PHANFUMAN_TREE CreateHanfuManTree(PDATA_INFO pDataInfo,int len);
void EnumHanfuManCode(PHANFUMAN_TREE tree);
void DestroyTree(PHANFUMAN_TREE tree);

#endif

#include <Windows.h>
#include <iostream>
#include <stdlib.h>
#include <time.h>

#include "HanfuMan.h"

#define TEST_DATA_LEN 16

void InsertSort(PDATA_INFO pDataInfo,int len,unsigned char data,unsigned short dataTimes);
//哈夫曼编码，返回值为编码后的数据位数 一个字节有8位
int HanfuManEncode(unsigned char* data,int dataLen,unsigned char **encodeData);
//哈夫曼解压缩，返回值为解压缩后的数据字节数
int HanfuManDecode(PHANFUMAN_TREE tree,unsigned char* data,int dataBitLen,unsigned char **decodeData);

//编码表,用于0-255之间
static HANFUMAN_CODE_ITEM g_HanfuManCodeTable[256] = {0};

BOOL TestHanfuMan()
{
	BOOL bRet = FALSE;
	unsigned char *p = (unsigned char*)new unsigned char[TEST_DATA_LEN];
	if(!p)
	{
		return FALSE;
	}
	memset(p,0,TEST_DATA_LEN);

	srand(time(NULL));
	for(int i=0;i<TEST_DATA_LEN;i++)
	{
		p[i] = rand()%256; //随机生成数据内容
	}

	//统计0-255之间每个数字出现的次数
	unsigned short times[256] = {0};
	for(int i=0;i<TEST_DATA_LEN;i++)
	{
		times[p[i]]++; 
	}

	int count = 0;//统计有出现的数字个数
	for(int i=0;i<256;i++)
	{
		if(times[i])
		{
			count++;
		}
	}

	PDATA_INFO pDataInfo = (PDATA_INFO)new DATA_INFO[count];
	if(!pDataInfo)
	{
		goto RET;
	}
	memset(pDataInfo,0,count*sizeof(DATA_INFO));

	int len = 0;
	for(int i=0;i<256;i++)
	{
		if(times[i])
		{
			//使用插入排序，把0-255之间出现的数字的次数进行从小到大排序
			InsertSort(pDataInfo,len,i,times[i]);
			len++;
		}
	}

	PHANFUMAN_TREE tree = CreateHanfuManTree(pDataInfo,len);
	EnumHanfuManCode(tree);

	unsigned char *pEncode = NULL;
	int encodeBitLen = HanfuManEncode(p,TEST_DATA_LEN,&pEncode); //编码数据
	printf("Bytes Before encode = %d Bytes Arter encode = %d\r\n",TEST_DATA_LEN,(encodeBitLen+7)/8);

	unsigned char *pDecode = NULL;
	int decodeByteLen = HanfuManDecode(tree,pEncode,encodeBitLen,&pDecode);

	if(decodeByteLen != TEST_DATA_LEN)
	{
		printf("Decode Fail...Len is not match\r\n");
	}
	else
	{
		if(memcmp(p,pDecode,TEST_DATA_LEN))
		{
			printf("Decode Fail... Decode data fail\r\n");
		}
		else
		{
			printf("Decode Success\r\n");
		}
	}

	if(!pEncode)
	{
		delete []pEncode;
		pEncode = NULL;
	}
	if(!pDecode)
	{
		delete []pDecode;
		pDecode = NULL;
	}

	DestroyTree(tree);

RET:
	if(pDataInfo)
	{
		delete [] pDataInfo;
	}
	if(p)
	{
		delete [] p;
	}

	return bRet;
}

//哈夫曼编码，返回值为编码后的数据位数 一个字节有8位
int HanfuManEncode(unsigned char* data,int dataLen,unsigned char **encodeData)
{
	if(!data || dataLen<=0)
	{
		return 0;
	}

	//存储编码后的数据
	*encodeData = (unsigned char *)new unsigned char[dataLen*8];
	if(!*encodeData)
	{
		return 0;
	}
	memset(*encodeData,0,(dataLen*8)*sizeof(unsigned char));

	int byteIndex = 0;
	int bitIndexOfByte = 7;

	unsigned char bitHelper[8] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};

	for(int i=0;i<dataLen;i++) 
	{
		for(int j=0;j<(g_HanfuManCodeTable[data[i]]).codeLen;j++)
		{
			int codeByteIndex = j/8;
			int codeBitIndexOfByte = j%8;
			if((g_HanfuManCodeTable[data[i]]).data[codeByteIndex] & bitHelper[codeBitIndexOfByte])
			{
				(*encodeData)[byteIndex] |= bitHelper[bitIndexOfByte];
			}
			//达到了一个字节，则需要设置下一个字节当中的位域
			if(-1 == --bitIndexOfByte)
			{
				byteIndex++;
				bitIndexOfByte = 7;
			}
		}
	}

	return byteIndex*8 + (7 - bitIndexOfByte);
}

//哈夫曼解压缩，返回值为解压缩后的数据字节数
int HanfuManDecode(PHANFUMAN_TREE tree,unsigned char* data,int dataBitLen,unsigned char **decodeData)
{
	if(!data || dataBitLen<=0)
	{
		return 0;
	}

	//存储解码后的数据
	*decodeData = (unsigned char *)new unsigned char[dataBitLen];
	if(!*decodeData)
	{
		return 0;
	}
	memset(*decodeData,0,(dataBitLen)*sizeof(unsigned char));

	int decodeIndex = 0;
	unsigned char bitHelper[8] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};

	PHANFUMAN_TREE pTree = tree;

	for(int i=0;i<dataBitLen;i++)
	{
		int codeByteIndex = i/8;
		int codeBitIndexOfByte = i%8;
		if(data[codeByteIndex] & bitHelper[7-codeBitIndexOfByte])
		{
			pTree = pTree->right; //如果是1,走到右子树
		}
		else
		{
			pTree = pTree->left; //如果是0,走到左子树
		}

		//叶子节点，则输出解码数据
		if(!pTree->left && !pTree->right)
		{
			(*decodeData)[decodeIndex++] = pTree->data;
			pTree = tree;
		}
	}

	return decodeIndex;
}

void InsertSort(PDATA_INFO pDataInfo,int len,unsigned char data,unsigned short dataTimes)
{
	if(0 == len)
	{
		pDataInfo[0].data = data;
		pDataInfo[0].times = dataTimes;
		return;
	}

	int inserIndex = 0;
	//使用插入排序
	for(inserIndex=0;inserIndex<len;inserIndex++)
	{
		if(dataTimes >= pDataInfo[inserIndex].times)
		{
			continue;
		}
		break;
	}

	for(int i=len-1;i>=inserIndex;i--)
	{
		memcpy(&pDataInfo[i+1],&pDataInfo[i],sizeof(DATA_INFO));
	}
	//插入新数据
	pDataInfo[inserIndex].data = data;
	pDataInfo[inserIndex].times = dataTimes;
}

void InsertSortTree(PHANFUMAN_TREE *pSubTree,int subTreeCount,PHANFUMAN_TREE insertTree)
{
	if(0 == subTreeCount)
	{
		pSubTree[0] = insertTree;
		return;
	}

	int inserIndex = 0;
	//使用插入排序
	for(inserIndex=0;inserIndex<subTreeCount;inserIndex++)
	{
		if(insertTree->weight >= (pSubTree[inserIndex])->weight)
		{
			continue;
		}
		break;
	}

	for(int i=subTreeCount-1;i>=inserIndex;i--)
	{
		pSubTree[i+1] = pSubTree[i];
	}
	//插入新数据
	pSubTree[inserIndex] = insertTree;
}

void RefreshSubTrees(PHANFUMAN_TREE *pSubTree,int subTreeCount,PHANFUMAN_TREE mergeTree)
{
	for(int i=2;i<subTreeCount;i++)
	{
		pSubTree[i-2] = pSubTree[i];
	}
	
	//插入排序，按照权重的从小到大顺序排序
	InsertSortTree(pSubTree,subTreeCount-2,mergeTree);
}

//合并2棵子树,pSubTree1的权重默认比pSubTree2的小
PHANFUMAN_TREE MergeTree(PHANFUMAN_TREE pLeftSubTree,PHANFUMAN_TREE pRightSubTree)
{
	PHANFUMAN_TREE mergeRoot = new HANFUMAN_TREE;

	if(!mergeRoot)
	{
		return NULL;
	}

	mergeRoot->data = 0;

	pLeftSubTree->parent = mergeRoot;
	mergeRoot->weight = pLeftSubTree->weight;
	//pLeftSubTree 默认不为空
	if(pRightSubTree)
	{
		mergeRoot->weight += pRightSubTree->weight;
		pRightSubTree->parent = mergeRoot;
	}

	mergeRoot->parent = NULL;
	mergeRoot->left = pLeftSubTree;
	mergeRoot->right = pRightSubTree;

	return mergeRoot;
}

//创建新树,用于创建叶子节点
PHANFUMAN_TREE CreateLeaf(PDATA_INFO pDataInfo)
{
	PHANFUMAN_TREE leafTree = new HANFUMAN_TREE;

	if(!leafTree)
	{
		return NULL;
	}

	leafTree->data = pDataInfo->data;
	leafTree->weight = pDataInfo->times;

	leafTree->parent = NULL;
	leafTree->left = NULL;
	leafTree->right = NULL;

	return leafTree;
}

//创建哈夫曼编码树
PHANFUMAN_TREE CreateHanfuManTree(PDATA_INFO pDataInfo,int len)
{
	if(len<=0)
	{
		return NULL;
	}

	int dataIndex = 0;
	//最多只可能出现len+1/2个子树，用于保存编码过程可能出现的全部子树的根节点指针
	PHANFUMAN_TREE *pSubTree = (PHANFUMAN_TREE*) new PHANFUMAN_TREE[(len+1)/2];
	PHANFUMAN_TREE root = NULL;
	int subTreeCount = 0; //子树的个数
	HANFUMAN_SELECT_HELPER  selectHelper;

	memset(pSubTree,0,sizeof(PHANFUMAN_TREE)*((len+1)/2));

	while(dataIndex<len)
	{
		//对比数组中剩余未编码的数据和各个子树选择2个权重最小的,如果权重相同，优先选择子树中的
		//由于数组和子树都已经按照从小到大的顺序，因此直接选取对比即可
		if(subTreeCount>=2)
		{
			selectHelper.firstMinIndex = 0;
			selectHelper.secondMinIndex = 1;	
		}
		else
		{
			if(subTreeCount>=1)
			{
				selectHelper.firstMinIndex = 0;
			}
		}

		if(-1 == selectHelper.firstMinIndex)
		{
			selectHelper.firstMinIndex = dataIndex;
			selectHelper.firstMinType = INDEX_TYPE_INFO;
			if(++dataIndex<len)
			{
				selectHelper.secondMinIndex = dataIndex++;
				selectHelper.secondMinType = INDEX_TYPE_INFO;
			}
		}
		else
		{
			if(pDataInfo[dataIndex].times < (pSubTree[selectHelper.firstMinIndex])->weight)
			{
				selectHelper.secondMinIndex = selectHelper.firstMinIndex;

				selectHelper.firstMinIndex = dataIndex;
				selectHelper.firstMinType = INDEX_TYPE_INFO;

				if( (++dataIndex<len) && ( pDataInfo[dataIndex].times < (pSubTree[selectHelper.secondMinIndex])->weight  ) )
				{
					selectHelper.secondMinIndex = dataIndex++;
					selectHelper.secondMinType = INDEX_TYPE_INFO;
				}
			}
			else
			{
				if( (-1==selectHelper.secondMinIndex) || (pDataInfo[dataIndex].times < (pSubTree[selectHelper.secondMinIndex])->weight))
				{
					selectHelper.secondMinIndex = dataIndex++;
					selectHelper.secondMinType = INDEX_TYPE_INFO;
				}
			}
		}//至此，已经选择出了2个最小权重的

		if(INDEX_TYPE_TREE == selectHelper.firstMinType && INDEX_TYPE_TREE == selectHelper.secondMinType)
		{
			//合并2棵子树
			PHANFUMAN_TREE mergeTree = MergeTree(pSubTree[0],pSubTree[1]);
			if(!mergeTree)
			{
				exit(0);
			}
			RefreshSubTrees(pSubTree,subTreeCount,mergeTree);

			subTreeCount--;
		}
		if(INDEX_TYPE_TREE == selectHelper.firstMinType && INDEX_TYPE_INFO == selectHelper.secondMinType)
		{
			PHANFUMAN_TREE newLeaf = CreateLeaf(&pDataInfo[selectHelper.secondMinIndex]);
			if(!newLeaf)
			{
				exit(0);
			}
			PHANFUMAN_TREE mergeTree = MergeTree(pSubTree[0],newLeaf);
			if(!mergeTree)
			{
				exit(0);
			}
			for(int i=1;i<subTreeCount;i++)
			{
				pSubTree[i-1] = pSubTree[i];
			}

			InsertSortTree(pSubTree,subTreeCount-1,mergeTree);//插入子树后，子树的数量不变
		}
		if(INDEX_TYPE_INFO == selectHelper.firstMinType && INDEX_TYPE_INFO == selectHelper.secondMinType)
		{
			PHANFUMAN_TREE leftLeaf = CreateLeaf(&pDataInfo[selectHelper.firstMinIndex]);
			if(!leftLeaf)
			{
				exit(0);
			}
			PHANFUMAN_TREE rightLeaf = CreateLeaf(&pDataInfo[selectHelper.secondMinIndex]);
			if(!leftLeaf)
			{
				exit(0);
			}
			PHANFUMAN_TREE mergeTree = MergeTree(leftLeaf,rightLeaf);
			if(!mergeTree)
			{
				exit(0);
			}
			InsertSortTree(pSubTree,subTreeCount,mergeTree);
			subTreeCount++; //插入子树后，子树的数量+1
		}
		if(INDEX_TYPE_INFO == selectHelper.firstMinType && INDEX_TYPE_TREE == selectHelper.secondMinType)
		{
			if(-1 == selectHelper.secondMinIndex)
			{
				PHANFUMAN_TREE leftLeaf = CreateLeaf(&pDataInfo[selectHelper.firstMinIndex]);
				if(!leftLeaf)
				{
					exit(0);
				}
				PHANFUMAN_TREE mergeTree = MergeTree(leftLeaf,NULL);
				if(!mergeTree)
				{
					exit(0);
				}
				InsertSortTree(pSubTree,subTreeCount,mergeTree);
				subTreeCount++; 
			}
			else
			{
				PHANFUMAN_TREE leftLeaf = CreateLeaf(&pDataInfo[selectHelper.firstMinIndex]);
				if(!leftLeaf)
				{
					exit(0);
				}
				PHANFUMAN_TREE mergeTree = MergeTree(leftLeaf,pSubTree[selectHelper.secondMinIndex]);
				if(!mergeTree)
				{
					exit(0);
				}
				for(int i=1;i<subTreeCount;i++)
				{
					pSubTree[i-1] = pSubTree[i];
				}

				InsertSortTree(pSubTree,subTreeCount-1,mergeTree);
			}
		}

		selectHelper.Init();
	}

	//合并sub trees
	while(subTreeCount>1)
	{
		//合并2棵子树
		PHANFUMAN_TREE mergeTree = MergeTree(pSubTree[0],pSubTree[1]);
		if(!mergeTree)
		{
			exit(0);
		}
		RefreshSubTrees(pSubTree,subTreeCount,mergeTree);

		subTreeCount--;
	}

	//最后子树中只剩下一课，这棵树即为编码树
	PHANFUMAN_TREE tree = pSubTree[0];
	delete [] pSubTree;
	
	return tree;
}

//释放树
void DestroyTree(PHANFUMAN_TREE tree)
{
	if(!tree)
	{
		return;
	}

	DestroyTree(tree->left); //刪除左子树
	DestroyTree(tree->right);//删除右子树

	delete tree; //删除根节点
	tree = NULL;
}

//通过叶子的父节点向上
void PrintHanfuManCode(PHANFUMAN_TREE tree,int *codeLen,unsigned char data)
{
	if(!tree)
	{
		return;
	}

	PHANFUMAN_TREE parent = tree->parent;
	if(!parent)
	{
		return;
	}

	PrintHanfuManCode(parent,codeLen,data);
	if(parent->left == tree)
	{
		(*codeLen)++;
		printf("0");
		//默认值就是为0，因此编码表元素不需要设置数据，长度增加1个位域即可
		g_HanfuManCodeTable[data].codeLen++;
	}
	else
	{
		(*codeLen)++;
		printf("1");
		//需要设置编码表元素的第g_HanfuManCodeTable[data].codeLen位为1
		int byteIndex = g_HanfuManCodeTable[data].codeLen/8;
		int bitIndexOfByte = g_HanfuManCodeTable[data].codeLen%8;
		unsigned char bitHelper[8] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
		g_HanfuManCodeTable[data].data[byteIndex] |= bitHelper[bitIndexOfByte];
		g_HanfuManCodeTable[data].codeLen++;
		//如果某个字段的编码位域为1101，则设置后，g_HanfuManCodeTable[data].data[0]第1位为1，第二位为1，第三位为0，第四为为1，即1011
		//如果某个字段的编码位域为1011 1111 1101，则设置后，g_HanfuManCodeTable[data].data[0] = 1111 1101
		//g_HanfuManCodeTable[data].data[1] = 0000 1011 即保存的顺序和我们阅读的顺序刚好相反了
	}
}


//通过二次遍历编码树，枚举得到每个data的哈夫曼编码
void EnumHanfuManCode(PHANFUMAN_TREE tree)
{
	if(!tree)
	{
		return;
	}

	//叶子节点
	if(!tree->left && !tree->right)
	{
		int codeLen = 0;
		printf("data value = 0x%2x    HanfuMan Code = ",tree->data);
		PrintHanfuManCode(tree,&codeLen,tree->data);
		printf("   CodeLen = %d\r\n",codeLen);
		return;
	}
	
	if(tree->left)
	{
		EnumHanfuManCode(tree->left);
	}

	if(tree->right)
	{
		EnumHanfuManCode(tree->right);
	}
}

#include <Windows.h>
#include <stdio.h>
#include "HanfuMan.h"


int main(int agrc,char* argv[])
{
	TestHanfuMan();
	
	getchar();
	return 0;
}

         这里，是通过随机生成的压缩数据，测试数据大小  #define TEST_DATA_LEN 16。测试结果如下：