数据压缩技术论文

霍夫曼编码

摘要

在现代社会，通信的发展，使得现代社会更加丰富多彩，我们可以随时随地在任何地方了解到世界各地的信息，而这又必须依赖信息的传递。在信息化高度发达的当今社会，我们必须对信息的传递有着较高的要求，我们希望信息在传递的过程中，能够保持节省性和保密性和无损性，而著名的霍夫曼编码就能够达到这样的要求。因此研究霍夫曼编码对信息的压缩和解压就时相当有必要的，我们用C++对霍夫曼编码给出简单的算法以实现对文件的压缩和解压。

【关键词】霍夫曼编码压缩解压C++

Abstract

In the modern society, communication development makes the modern society more rich and colorful, we can at any time anywhere in any place to all over the world know the information, which must be dependent on the information transfer. In the information highly developed in today's society, we must have the information transfer has a higher request, we hope that in the process of information transmission, can maintain save sex and confidentiality and nondestructive sex, and famous Huffman coding can achieve such requirement. So the Huffman coding information to compression and decompression is quite necessary when, we use c + + to Huffman coding give simple algorithm for document to realize the compression and decompression.

Keywords: Huffman coding compression decompression C + +

【引言】

霍夫曼编码(Huffman Coding)是一种编码方式，霍夫曼编码是可变字长编码(VLC)的一种。uffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫作Huffman编码。

霍夫曼编码原理：

霍夫曼编码的基本思想：输入一个待编码的串，首先统计串中各字符出现的次数，称之为频次，假设统计频次的数组为count[]，则霍夫曼编码每次找出count 数组中的值最小的两个分别作为左右孩子，建立他们的父节点，循环这个操作2*n-1-n（n是不同的字符数）次，这样就把霍夫曼树建好了。建树的过程需要注意，首先把count数组里面的n个值初始化为霍夫曼树的n个叶子节点，他们的孩子节点的标号初始化为-1，父节点初始化为他本身的标号。接下来是编码，每次从霍夫曼树的叶子节点出发，依次向上找，假设当前的节点标号是i，那么他的父节点必然是myHuffmantree[i].parent，如果i是myHuffmantree[i].parent的左节点，则该节点的路径为0，如果是右节点，则该节点的路径为1。当向上找到一个节点，他的父节点标号就是他本身，就停止（说明该节点已经是根节点）。还有一个需要注意的地方：在查找当前权值最小的两个节点时，那些父节点不是他本身的节点不能考虑进去，因为这些节点已经被处理过了。

霍夫曼树：

下面是字符串agdfaghdabsb的霍夫曼编码的霍夫曼树：

字符串：

由上面的霍夫曼树可知各个字符的编码如下：

a: 01

b:010

d:011

f:100

g:101

h:110

s:111

所以整个串的编码为：

011010111000110111001101010111010

霍夫曼译码原理：

对于霍夫曼的译码，可以肯定的是其译码结果是唯一的。

证明：因为霍夫曼编码是根据霍夫曼树来确定的，霍夫曼树是一棵二叉树，编码的时候是从树根一直往下走，直到走到叶子节点为止，在其经过的路径上，如果是树的左子树则为0，否则为1。因为每一次都要走到树的叶子节点，多以不可能存在两个编码a和b，使得a是b的前缀或者b是a的前缀。所以编码一定可以唯一确定。

根据上面的结论，我们可以很清楚地直到译码的方法：

定义两个指针p1,p2，P1指向当前编码的开始位置，P2指向当前编码的位置，如果P1-P2这一段编码能在编码库里面找到完全对应的编码结果，则译码成功，该段编码的译码结果就是与编码库里完全对应的编码的字符。循环次操作，直到译码结束！

例子：

假设有一段字符含有a,,c,d三个字符，经过编码之后三个字符对应的编码结果分别为：

a:01

c:010

d:011

现在给你一段编码0110101，要求将其译码！

按照上面介绍的方法我们可以知道：

编码的前三个字符是且仅是d的编码，所以011译码为d，依次译码可得整串的译码结果为daa

霍夫曼编码源代码：

#include

#include

#include

#include

using namespace std;

#define INF 0x7fffffff //无穷大

struct Huffmantree //霍夫曼树的节点

{

int weight;

int parent,ld,rd;

};

struct myNode

{

char ch;

int num;

};

struct mycode //字符和其对应的编码

{

char ch; //字符

int s[50]; //ch的编码

int len; //编码长度

};

int nNode; //叶子节点数目

int totalNode; //霍夫曼树的总节点个数

char toCode[100000] ; //待编码的字符串

myNode myToCode[100000]; //待编码的字符串和权值

int weightOfToCode[100000] ; //字符串的权值！

Huffmantree myHuffmantree[1000000]; //霍夫曼树(数组模拟)

char allchar[1000000]; //所哟出现过的字符

mycode coder[1000000]; //字符与对应的编码

int Len; //待编码的字符的总长度

int Coding[100000]; //译码之后的01串

int lenOfCoding ; //01串的长度

void build(int n); //建立霍夫曼树

void select(int &a,int &b); //选择两个权值最小的节点

void Code(); //编码

void printCode(); //打印编码

void deCode(); //译码

int match(int l,int h);

int main()

{

int i;

cout<<"\n=============================霍夫曼编码程序=============================";

cout<<"\n

cout<<"

while(1)

{

printf("请输入待编码的字符串\n");

int flag=0;

gets(toCode);

int len=strlen(toCode);

if(len==1)

{

flag=1;

}

Len=len;

mapmyMap;

for(i=0;i

{

myMap[toCode[i]]++;

}

map::iterator iter;

int h=1;

for(iter=myMap.begin();iter!=myMap.end();iter++)

{

myToCode[h].ch=iter->first;

allchar[h]=iter->first;

weightOfToCode[h]=iter->second;

myToCode[h++].num=iter->second;

}

nNode=h-1; //叶子节点个数

cout<<"----------------------字符统计如下--------------------------------------"<

cout<<" 字符次数"<

for(i=1;i

{

cout<<" "<

}

cout<

totalNode=nNode; //totalNode初始值为nNode

cout<<"-----------霍夫曼树节点信息如下(子节点为-1表示是叶子节点)---------------"<

build(nNode);

cout<

Code();

cout<<"\n-------------------------字符串的编码结果如下--------------------------\n";

printCode();

cout<<"\n-------------------------01串的译码结果如下-----------------------------\n";

deCode();

cout<<"\n是否继续？(Y/N)\n";

char con[10];

cin>>con;

char fang=toupper(con[0]);

if(fang=='N')

{

break;

}

getchar();

}

return 0;

}

void build(int n) //建立霍夫曼树

{

int i;

int m=2*n-1; //n个叶子节点的霍夫曼树总节点数为2*n-1

for(i=1;i<=n;i++) //初始化霍夫曼数组

{

myHuffmantree[i].weight=weightOfToCode[i]; //叶子节点权值为字符出现次数

myHuffmantree[i].ld=-1; //叶子节点没有左孩子

myHuffmantree[i].rd=-1; //叶子节点没有右孩子

myHuffmantree[i].parent=i; //叶子节点父节点先初始化为他本身

}

for(i=n+1;i<=m;i++)

{

int a,b;

select(a,b);

myHuffmantree[a].parent=i;

myHuffmantree[b].parent=i;

myHuffmantree[i].ld=a;

myHuffmantree[i].rd=b;

myHuffmantree[i].weight=myHuffmantree[a].weight+myHuffmantree[b].weight;

myHuffmantree[i].parent=i;

}

for(i=1;i<=totalNode;i++)

{

printf("节点：%3d 权值：%3d 左节点：%3d 右节点：%3d 父节点：%3d \n",i,myHuffmantree[i].weight,myHuffmantree[i].ld,myHuffmantree[i].rd,myHuffmantree[i].paren t);

}

}

void Code() //编码

{

int i,j;

int numOfCode[100000];

cout<<"--------------------------各字符编码结果如下----------------------------"<

if(Len==1)

{

cout<

return ;

}

for(i=1;i<=nNode;i++)

{

j=i;

int h=0;

while(myHuffmantree[j].parent!=j)

{

int x=j;

j=myHuffmantree[j].parent;

if(myHuffmantree[j].ld==x)

{

numOfCode[h++]=0;

}

else if(myHuffmantree[j].rd==x)

{

numOfCode[h++]=1;

}

}

cout<<" "<

int x=0;

coder[i].len=h;

coder[i].ch=allchar[i];

for(int k=h-1;k>=0;k--)

{

coder[i].s[x++]=numOfCode[k];

printf("%d",numOfCode[k]);

}

cout<

}

}

void select(int &a,int &b) //选择两个权值最小的节点

{

int i;

int min1=INF;

int min2=INF;

int sign1=1; //最小值的下标

int sign2=2; //次小值的下标

for(i=1;i<=totalNode;i++)

{

if(myHuffmantree[i].parent==i) //说明其是已经更新过的节点

{

if(myHuffmantree[i].weight

{

min1=myHuffmantree[i].weight;

sign1=i;

}

}

}

for(i=1;i<=totalNode;i++)

{

if(myHuffmantree[i].parent==i) //说明其是已经更新过的节点

{

if(myHuffmantree[i].weight

{

min2=myHuffmantree[i].weight;

sign2=i;

}

}

}

a=sign1;

b=sign2;

totalNode++; //总节点数加1

}

void printCode() //打印编码结果！

{

int i;

if(Len==1) //长度为1的时候特殊考虑

{

cout<<"0\n";

return ;

}

int h=0;

for(i=0;i

{

for(int j=1;j<=nNode;j++)

{

if(toCode[i]==coder[j].ch)

{

for(int k=0;k

{

printf("%d",coder[j].s[k]);

Coding[h++]=coder[j].s[k];

}

}

}

}

lenOfCoding=h;

cout<

}

void deCode() //译码

{

int i,j;

int begin=0;

for(i=0;i

{

if(match(begin,i)!=-1)

{

int x=match(begin,i);

printf("%c",coder[x].ch);

begin=i+1;

}

}

printf("\n");

}

int match(int l,int h) //译码的辅助函数（寻找匹配）{

int i,j,k;

int flag=0;

for(i=1;i<=nNode;i++)

{

if(coder[i].len!=h-l+1)

{

continue;

}

k=l;

for(j=0;j

{

if(Coding[k]!=coder[i].s[j])

{

break;

}

if(j==coder[i].len-1)

{

flag=1;

goto ok;

}

k++;

}

}

ok:;

if(flag==1) //查找成功返回对应的下表

{

return i;

}

else //查找不成功返回-1；

{

return -1;

}

}

霍夫曼编码代码分析：

1.运行环境：win7操作系统，Inter(R) Core(TM) Duo t6600 @

2.20GHz 2.20GHz

内存：2.00GB，32位操作系统

2.程序运行结果：

3. 程序功能模块分析：

整个程序包含6个函数：

A． void build(int n);

B． void select(int &a,int &b);

C． void Code();

D． void printCode();

E． void deCode();

F． int match(int l,int h);

其中A是用来建立霍夫曼树，B是在A中调用的一个辅助函数，用来查找两个权值最小的节点的下标，C是对字符串编码，D是现实编码结果，E是译码01串,F是E的辅助函数，用来寻找编码的匹配。

包含3个结构体：

A．struct Huffmantree //霍夫曼树的节点

{

int weight;

int parent,ld,rd;

};

B．struct myNode //字符和其权值

{

char ch; //字符

int num; //权值

};

C．struct mycode //字符和其对应的编码

{

char ch; //字符

int s[50]; //ch的编码

int len; //编码长度

};

各结构功能如注释！

4. 程序效率分析：

该程序要编码的字符比较长，达到10^8长度时运行就会很慢，主要原因在于在建树时每次选择权值最小的两个是用暴力枚举的，还有译码时每次都要在编码库里面去一一匹配，假设编码之后的01串长度为10^7，而其中出现的不同字符数为200，在最坏情况下，译码的时候就需要200*10^7的时间，在这种情况下程序运行就会比较慢，当然，这只是最坏估计，实际上是不可能达到这么高的时间复杂度的，因为不可能每次寻找编码匹配时都要遍历到最后才找到！

5．程序的优化：

既然用该方法效率会很低，那么有没有什么优化方法呢？答案是肯定的！在建树的时候可以用一个优先队列将个节点信息存在队列里面，优先队列按照节点的权值从小到大排序，所以每次只需取出队列的前两个节点就是权值最小的两个节点，而不需遍历所有节点来选择最小的。优先队列里面是右堆来排序的，时间复杂度很低，为lg(n)，所以用有限队列能大幅度降低程序建树的时间复杂度！

霍夫曼编码的应用：

随着信息技术的飞速发展，各种各样的信息需要传输，传输信息就要得先经过编码，然后再译码，可见编码技术的提高对整个信息产业有着举足轻重的作用。霍夫曼编码是一种可变的无损压缩方法，其效率也比较高，所以在当今网络传输中意义重大。霍夫曼树是一棵最有二叉树，在各种程序设计中都用到它来降低程序运行的时间复杂度。

参考文献

[1]谭浩强C++面向对象程序设计[M]. 北京：清华大学出版社.2007.

[2]谭浩强C程序设计[M].北京：清华大学出版社.2005.

[3]田丽华编码理论[M].西安：西安电子科技大学出版社，2007.