信息论与编码实验一

信息论与纠错编码实验报告

实验一

一、实验目的

利用程序实现哈夫曼编码，以加深对哈夫曼编码的理解，并锻炼编程能力。

二、实验内容

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

程序源码：

/*-------------------------------------------------------------------------

* Name: 哈夫曼编码源代码。

* Date: 2011.04.16

* Author: Jeffrey Hill

* 在 Win-TC 下测试通过

* 实现过程：着先通过 HuffmanTree() 函数构造哈夫曼树，然后在主函数main()中

* 自底向上开始(也就是从数组序号为零的结点开始)向上层层判断，若在

* 父结点左侧，则置码为 0,若在右侧,则置码为 1。最后输出生成的编码。

*------------------------------------------------------------------------*/

#include

#define MAXBIT 100

#define MAXVALUE 10000

#define MAXLEAF 30

#define MAXNODE MAXLEAF*2 -1

typedef struct

{

int bit[MAXBIT];

int start;

} HCodeType; /* 编码结构体 */

typedef struct

{

int weight;

int parent;

int lchild;

int rchild;

} HNodeType; /* 结点结构体 */

/* 构造一颗哈夫曼树 */

void HuffmanTree (HNodeType HuffNode[MAXNODE], int n)

{

/* i、j：循环变量，m1、m2：构造哈夫曼树不同过程中两个最小权值结点的权值，

x1、x2：构造哈夫曼树不同过程中两个最小权值结点在数组中的序号。*/

int i, j, m1, m2, x1, x2;

/* 初始化存放哈夫曼树数组 HuffNode[] 中的结点 */

for (i=0; i<2*n-1; i++)

{

HuffNode[i].weight = 0;

HuffNode[i].parent =-1;

HuffNode[i].lchild =-1;

HuffNode[i].lchild =-1;

} /* end for */

/* 输入 n 个叶子结点的权值 */

for (i=0; i

{

printf ("Please input weight of leaf node %d: \n", i);

scanf ("%d", &HuffNode[i].weight);

} /* end for */

/* 循环构造 Huffman 树 */

for (i=0; i

{

m1=m2=MAXVALUE; /* m1、m2中存放两个无父结点且结点权值最小的两个结点 */

x1=x2=0;

/* 找出所有结点中权值最小、无父结点的两个结点，并合并之为一颗二叉树 */

for (j=0; j

{

if (HuffNode[j].weight < m1 && HuffNode[j].parent==-1) {

m2=m1;

x2=x1;

m1=HuffNode[j].weight;

x1=j;

}

else if (HuffNode[j].weight < m2 && HuffNode[j].parent==-1) {

m2=HuffNode[j].weight;

x2=j;

}

} /* end for */

/* 设置找到的两个子结点 x1、x2 的父结点信息 */

HuffNode[x1].parent = n+i;

HuffNode[x2].parent = n+i;

HuffNode[n+i].weight = HuffNode[x1].weight + HuffNode[x2].weight;

HuffNode[n+i].lchild = x1;

HuffNode[n+i].rchild = x2;

printf ("x1.weight and x2.weight in round %d: %d, %d\n", i+1, HuffNode[x1].weight, HuffNode[x2].weight); /* 用于测试 */

printf ("\n");

} /* end for */

} /* end HuffmanTree */

int main(void)

{

HNodeType HuffNode[MAXNODE]; /* 定义一个结点结构体数组*/

HCodeType HuffCode[MAXLEAF], cd; /* 定义一个编码结构体数组，同时定义一个临时变量来存放求解编码时的信息 */

int i, j, c, p, n;

printf ("Please input n:\n");

scanf ("%d", &n);

HuffmanTree (HuffNode, n);

for (i=0; i < n; i++)

{

cd.start = n-1;

c = i;

p = HuffNode[c].parent;

while (p != -1) /* 父结点存在 */

{

if (HuffNode[p].lchild == c)

cd.bit[cd.start] = 0;

else

cd.bit[cd.start] = 1;

cd.start--; /* 求编码的低一位 */

c=p;

p=HuffNode[c].parent; /* 设置下一循环条件 */

} /* end while */

/* 保存求出的每个叶结点的哈夫曼编码和编码的起始位 */

for (j=cd.start+1; j

{ HuffCode[i].bit[j] = cd.bit[j];}

HuffCode[i].start = cd.start;

} /* end for */

/* 输出已保存好的所有存在编码的哈夫曼编码 */

for (i=0; i

{

printf ("%d 's Huffman code is: ", i);

for (j=HuffCode[i].start+1; j < n; j++)

{

printf ("%d", HuffCode[i].bit[j]);

}

printf ("\n");

}

return 0;

}

源码分析：

我们编写的代码的中心思想是利用用户输入的信息，首先建立哈夫曼树，再对树进行遍历从而得出哈夫曼编码。

在代码编写上我们结合了c和c++两种语言的优点，即利用了c的结构体，因为这是个小程序如果用c++的类会使程序变得复杂得不偿失；利用了c++的iostream库，因为c++的输入输出函数很简单，易于控制。

在具体实现上，我们首先定义了两个结构体：HTNode和HCode。

HTNode用以记录结点的信息，其成员有data结点值、weight权重、parent 双亲结点、lchild左孩子结点、rchild右孩子结点。

HCode用以记录结点的哈夫曼编码，其成员有cd[N]、codeend，codeend记录边界信息，其中cd[0]至cd[codeend-1]记录该结点的哈夫曼编码。

CreateHT()函数为哈夫曼树的构造函数，其函数参数为HTNode ht[](结点数组)， n(结点个数)。首先我们执行

for(i=0; i<2*n-1; i++)

ht[i].parent=ht[i].lchild=ht[i].rchild=-1

利用for循环将所有结点的相关域置为-1。

再利用for循环for(i=n; i<2*n-1; i++)对每个结点遍历设置其相关信息。需要注意的是对于具有n个叶子结点的哈夫曼树，总共有2n-1个结点，所以循环变量为0到2*n-1。

在for循环内，执行

min1=min2=32767 ; lnode=rnode=-1;

即将min1和min2初始化为最大值，将lnode和rnode初始化为无效值。

继而执行

for(k=0; k<=i-1; k++)

if(ht[k].parent==-1)

{ if(ht[k].weight

{ min2=min1;

rnode=lnode;

min1=ht[k].weight;

lnode=k;

}

else if(ht[k].weight

{

min2=ht[k].weight;

rnode=k;}}

从ht[]的0至i-1中寻找最小的尚未构造二叉树(即其双亲结点为-1)的两个结点组成树，要注意的是i的值会变化，因为在建树的过程中结点数目会增加。最后将结点的信息设置好即完成了哈夫曼树的构造。

CreatHcode()为哈夫曼编码的生成函数，其参数为HTNode ht[](结点数组),HCode hcd[]（记录结点编码的数组）, n（结点个数）。CreatHcode()的核心函数是下面的while循环。

while(f!=-1)

{ if(ht[f].lchild==c)

hc.cd[hc.codeend++]='0';

else

hc.cd[hc.codeend++]='1';

c=f;

f=ht[f].parent;}

此处采用自底向上的查找方式，利用while(f!=-1)控制查到到根结点即停止，if(ht[f].lchild==c)

hc.cd[hc.codeend++]='0'

else

hc.cd[hc.codeend++]='1'

判断是否为左孩子结点，若是则其编码为0，若不是则为1.

c=f

f=ht[f].parent

将自己的双亲结点赋给自己，并继续查找，直到查找到根节点。

运行结果：

输入的结点数为8，其结点为a、b、c、d、e，其出现的频率(权重)分别为:5、4、3、2、1。人工构造的哈夫曼树如下图所示：

由人工构造的哈夫曼树可得各字母的哈夫曼编码为：a:11 b:10 c:00 d:011

e:010

运行程序得到的结果如下：

其编码值与人工得出的编码值一致，证明了程序的正确性。