【数据压缩】Huffman原理与代码实现

页面导航:首页 > 软件编程 > C 语言 > 【数据压缩】Huffman原理与代码实现

【数据压缩】Huffman原理与代码实现

来源: 作者: 时间:2016-01-25 09:50 【

勿在浮沙筑高台Huffman算法也是一种无损压缩算法,但与上篇文章LZW压缩算法不同,Huffman需要得到每种字符出现概率的先验
勿在浮沙筑高台

Huffman算法也是一种无损压缩算法,但与上篇文章LZW压缩算法不同,Huffman需要得到每种字符出现概率的先验知识。通过计算字符序列中每种字符出现的频率,为每种字符进行唯一的编码设计,使得频率高的字符占的位数短,而频率低的字符长,来达到压缩的目的。通常可以节省20%~90%的空间,很大程度上依赖数据的特性!Huffman编码是变长编码,即每种字符对应的编码长度不唯一。

前缀码:任何一个字符的编码都不是同一字符集中另一种字符编码的前缀。Huffman编码为最优前缀码,即压缩后数据量最小。

---------------------------------------------------------------------------------------------------------------

Huffman算法:

1.统计字符序列的每种字符的频率,并为每种字符建立一个节点,节点权重为其频率;

2.初始化最小优先队列中,把上述的结点全部插入到队列中;

3.取出优先队列的前两种符号节点,并从优先队列中删除;

4.新建一个父节点,并把上述两个节点作为其左右孩子节点,父节点的权值为左右节点之和;

5.如果此时优先队列为空,则退出并返回父节点的指针!否则把父节点插入到优先队列中,重复步骤3;

----------------------------------------------------------------------------------------------------------------

通过上述建造的Huffman树,可以看到,每种字符结点都是叶子结点,编码方法:从根节点开始向左定义编码'0',向右定义为'1',遍历到叶子结点所得到的二值码串,即为此种字符的编码值。由于字符码字为前缀码,在译码过程中,每种字符可以参照Huffman树被唯一的译码出,但是前缀码的缺点是,错误具有传播功能,当有1位码字错误,此后的译码过程很可能都不正确;

\

代码实现:

 

/*
CSDN 勿在浮沙筑高台 
http://blog.csdn.net/luoshixian099
数据压缩--Huffman编码 2015年12月21日 
*/
#include 
#include 
#include "compress.h"
using namespace std;
void ShowCode(PNode root, vector &code);
int main()
{
	char A[] = "xxznxznnvcncvzzbzzvxxczbzvmnzvnnz";//原始数据
	UINT Length = sizeof(A)-1;
	Priority_Q queue(A, Length); //建立优先队列
	//输出每组字符的频率
	for (UINT i = 0; i <= queue.Heap_Size;i++)
	{
		cout << (char)(queue.table[i]->key) << "  Frequency:  " << queue.table[i]->Frequency << endl;
	}
	cout << "--------------------" << endl;
	PNode root = Build_Huffman_Tree(queue);//构建Huffman树
	vector code;
	ShowCode(root, code); //显示编码数据
	return 0;
}
void ShowCode(PNode root,vector &code)
{
   if (root!=NULL)
   {
	   if (root->_left == NULL && root->_right == NULL)  //叶子结点
	   {
		   cout << (char)(root->key) << "  code : " ;
		   for (UINT i = 0; i < code.size() ; i++)
		   {
			   cout << (int)code[i];
		   }
		   cout << endl;
		   return;
	   }
	   code.push_back(0);
	   ShowCode(root->_left,code);
	   code[code.size()-1] = 1;
	   ShowCode(root->_right,code);
	   code.resize(code.size()-1);
   }
}

\

/*
compress.cpp
*/
#include "compress.h"
Priority_Q::Priority_Q(char *A,int Length) //统计各种字符的频率
{
	for (int i = 0; i < 256; i++)
	{
		table[i] = new Node;
	}
	Heap_Size = 0;
	for (int i = 0; i < Length; i++)  //统计字符频率
	{
		bool Flag = true;
		for (int j = 0; j < Heap_Size; j++)
		{
           if ( table[j]->key == *(A+i) )
           {
			   table[j]->Frequency = table[j]->Frequency + 1;
			   Flag = false;
			   break;
           }
		}
		if (Flag)  //加入新的字符
		{
			table[Heap_Size]->key = *(A + i);
			table[Heap_Size]->Frequency = table[Heap_Size]->Frequency + 1;
			Heap_Size++;
		}
	}
	Heap_Size--;
	Build_Min_Heap(Heap_Size); //建立优先队列
}
void Priority_Q::Build_Min_Heap(UINT Length)
{
	for (int i = (int)(Length / 2); i >= 0; i--)
	{
		Min_Heapify(i);
	}
}
void Priority_Q::Min_Heapify(UINT i)
{
	UINT Smaller = i;
	UINT Left = 2 * i + 1;
	UINT Right = 2 * i + 2;

	if (Left <= Heap_Size && table[Left]->Frequency < table[i]->Frequency)  //判断是否小于其孩子的值
	{
		Smaller = Left;
	}
	if (Right <= Heap_Size && table[Right]->Frequency < table[Smaller]->Frequency)
	{
		Smaller = Right;
	}
	if (Smaller != i)                      //如果小于,就与其中最大的孩子调换位置
	{
		Swap(i, Smaller);
		Min_Heapify(Smaller);
	}
}
void Priority_Q::Swap(int x, int y) //交换两个元素的数据
{
	PNode temp = table[x];
	table[x] = table[y];
	table[y] = temp;
}
PNode CopyNode(PNode _src, PNode _dst)//拷贝数据
{
	_dst->Frequency = _src->Frequency;
	_dst->key = _src->key;
	_dst->_left = _src->_left;
	_dst->_right = _src->_right;
	return _dst;
}
PNode Priority_Q::Extract_Min()  //输出队列最前结点
{
	if (Heap_Size == EMPTY)
		return NULL;
	if (Heap_Size == 0)
	{
		Heap_Size = EMPTY;
		return table[0];
	}
	if (Heap_Size >= 0)                 
	{
		Swap(Heap_Size, 0);
		Heap_Size--;
		Min_Heapify(0);
	}
	return table[Heap_Size+1];
}
void Priority_Q::Insert(PNode pnode)//优先队列的插入
{
	Heap_Size++;
	CopyNode(pnode, table[Heap_Size]);
	delete pnode;
	UINT i = Heap_Size;
	while ( i > 0 && table[Parent(i)]->Frequency > table[i]->Frequency )
	{
		Swap(i, Parent(i));
		i = Parent(i);
	}
}
PNode Build_Huffman_Tree(Priority_Q &queue) //建立Huffman树
{
	PNode parent=NULL,left=NULL,right=NULL;
	while (queue.Heap_Size != EMPTY)
	{
		left = new Node;
		right = new Node;
		parent = new Node;
		CopyNode(queue.Extract_Min(), left); //取出两个元素
		CopyNode(queue.Extract_Min(), right);
		//复制左右节点数据
		parent->Frequency = right->Frequency + left->Frequency;//建立父节点
		parent->_left = left;
		parent->_right = right;
		if (queue.Heap_Size == EMPTY)
			break;
		queue.Insert(parent);  //再插入回优先队列
	}
	return parent;
}
/*
compress.h
*/
#ifndef COMPRESS
#define COMPRESS
#include 
#define UINT unsigned int 
#define UCHAR unsigned char 
#define EMPTY 0xFFFFFFFF
#define Parent(i) (UINT)(((i) - 1) / 2)
typedef struct Node   //结点
{
	Node::Node():key(EMPTY), Frequency(0),_left(NULL),_right(NULL){}
	UINT key;
	UINT Frequency;
	struct Node * _left;
	struct Node * _right;
}Node,*PNode;
class Priority_Q  //优先队列
{
public:
	Priority_Q(char *A, int Length);
	void Insert(PNode pnode); //插入
	PNode Extract_Min();  //取出元素
	UINT Heap_Size;  //队列的长度
	PNode table[256];  //建立256种结点
private:
	void Build_Min_Heap(UINT Length); //建立队列
	void Swap(int x, int y);   //交换两个元素
	void Min_Heapify(UINT i); //维护优先队列的性质
	
};
PNode Build_Huffman_Tree(Priority_Q &queue);//构建优先队列
#endif // COMPRESS
参考:

http://wenku.baidu.com/view/04a8a13b580216fc700afd2e.

Tags:

文章评论

最 近 更 新
热 点 排 行
Js与CSS工具
代码转换工具

<