哈夫曼代码调试

来源：互联网发布：知乎pc客户端下载编辑：程序博客网时间：2024/05/17 09:19

霍夫曼编码(Huffman Coding)是一种编码方法，霍夫曼编码是可变字长编码(VLC)的一种。

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

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

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

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

BABACAC ADADABB CBABEBE DDABEEEBB

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

2把出现次数（概率）最小的两个相加，并作为左右子树，重复此过程，直到概率值为1

第一次：将概率最低值3和4相加，组合成7：

第二次：将最低值5和7相加，组合成12：

第三次：将8和10相加，组合成18：

第四次：将最低值12和18相加，结束组合：

3 将每个二叉树的左边指定为0，右边指定为1

4 沿二叉树顶部到每个字符路径，获得每个符号的编码

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

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

霍夫曼编码的局限性

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

哈夫曼编码实现：

#include <stdio.h>
#include<stdlib.h>
#include<string.h>
int s2;
int s1;
int m;
typedef struct {
char ch;
int data;
int p,lc,rc;
}Htree,*Hufftree;
typedef char* Huffcode;
void select (Hufftree &Ht,int n)
{
char *cd;
int min1,min2;
min1=min2=32765;
s1=s2=0;
int i;
for (i=1;i<=n;i++)
{
if (!Ht[i].p)
if (Ht[i].data<min1)
{
min2=min1;
s2=s1;
min1=Ht[i].data;
s1=i;
}
else if (Ht[i].data<min2)
{
s2=i;
min2=Ht[i].data;
}
}
}
void Huffman(Hufftree &Ht,Huffcode Hc[],int *w,int n)
{
int start;
char *cd;
int i,c,f;
if (n<1)
return;
m=2*n-1;
Ht=(Htree*)malloc ((m+1)*sizeof(Htree));
for (i=1;i<=n;i++)
{
Ht[i].data=w[i-1];
Ht[i].p=0;
Ht[i].lc=-1;
Ht[i].rc=-1;
}
for(i=n+1;i<=m;i++)
{
Ht[i].data=0;
Ht[i].lc=-1;
Ht[i].rc=-1;
Ht[i].p=0;
}
for (i=n+1;i<=m;++i)
{
select(Ht,i-1);
Ht[s1].p=i;
Ht[s2].p=i;
Ht[i].lc=s1;
Ht[i].rc=s2;
Ht[i].data=Ht[s1].data+Ht[s2].data;
}
cd=(char *)malloc (n*sizeof(char));
start=0;
cd[n-1]='\0';
for (i=1;i<=n;i++)
{
start=n-1;
for(c=i,f=Ht[i].p;f!=0;c=f,f=Ht[f].p)
{
if (Ht[f].lc==c)
cd[--start]='0';
else
cd[--start]='1';
}
Hc[i]=(char*)malloc((n-start)*sizeof(char));
strcpy (Hc[i],&cd[start]);
}
}
void decode(Hufftree &Ht)
{
int i,j=0;
i=m;
char b[20];
printf("输入编码(以'#'为结束标志):\n");
scanf("%s",b);
printf("译码后的字符为:\n");
while(b[j]!='#')
{
//printf("%c ",b[j]);
if(b[j]=='0')
i=Ht[i].lc;
else
i=Ht[i].rc;
if(Ht[i].lc==-1)
{
printf("%d",Ht[i].data);
i=m; //每次译码从头开始
}
j++;
}
printf("\n");
}
int main ()
{
Hufftree Ht;
Huffcode *Hc;
int w[20];
int i,n;
printf(" 编码\n\n输入要编码字符个数:\n");
scanf("%d",&n);
Hc=(Huffcode*)malloc(n*sizeof(Huffcode));
printf("输入要编码的字符的频率:\n");
for (i=0;i<n;i++)
scanf("%d",&w[i]);
Huffman(Ht,Hc,w,n);
printf("字符编码为:\n");
for (i=1;i<=n;i++)
{
printf ("%d %s\n",w[i-1],Hc[i]);
}
printf(" 译码 \n");
decode(Ht);
return 0;
}

测试结果如下：

阅读全文

0 0