信息论与编码课程设计报告

信息论与编码课程设计报告

设计题目：统计信源熵与哈夫曼编码

专业班级

学号

学生姓名

指导教师

教师评分

2015年 3 月 25 日

目录

一、设计任务与要求 (3)

二、设计思路 (3)

三、设计流程图 (5)

四、程序运行及结果 (6)

五、心得体会 (8)

参考文献 (9)

附录：源程序 (10)

一、设计任务与要求

1.1设计目的

信息论与编码是信息、通信、电子工程专业的基础，对理论研究和工程应用均有重要的作用。通过对本次课程设计，我们将学到的理论知识用于实践，用软件编写程序实现具体的计算和逻辑问题，使我们对所学知识有更深层次的认知，加深对课本知识的理解。

1.2设计要求

（1）统计信源熵

要求：统计任意文本文件中各字符（不区分大小写）数量，计算字符概率，并计算信源熵。

（2）哈夫曼编码

要求：任意输入消息概率，利用哈夫曼编码方法进行编码，并计算信源熵和编码效率。

二、设计思路

2.1编码效率计算公式：

K X）

（

H

=

η

其中H（X）为信源熵，K表示平均码长。

2.3变长码的编码方法

能获得最佳码的编码方法主要有：

＆香农（Shannon）

＆费诺（Fano）

＆霍夫曼（Huffman）

本设计以霍夫曼编码为例；

（1）将信源消息符号按其出现的概率大小依次排列

p(x1)≥p(x2)≥…≥ p(xn)

（2）取两个概率最小的符号分别配以0和1，并将这两个概率相加作为一个新符号的概率，与未分配码元的符号重新排队。

（3）对重排后的两个概率最小符号重复步骤2的过程。

（4）继续上述过程，直到最后两个符号配以0和1为止。

（5）从最后一级开始，向前返回得到各个信源符号所对应的码元序列，即相应的码字。

2.3 具体设计思路

（1）统计信源熵

在VC++环境中进行编程

（1）运行程序，在对话框里输入一段英文，将26个英文字母及空格作为信源。（2）计算每个字母出现的次数（不区分大小写），再通过计算信源总大小来计算在本篇文章中每个字母出现的概率。

（3）通过信源熵计算公式来计算信源熵。

（2）哈夫曼编码

在VC++环境中进行编程

（1）输入概率矩阵，并检验是否正确，即各概率不能小于零，总概率之和等于一。

（2）建立各概率符号的位置索引矩阵Index,利于编码后从树根进行回溯,从而得出对应的编码

（3）输出所需的哈弗曼编码。

（4）计算信源熵，并计算平均码长，算出编码效率。

（5）输出结果。

三、设计流程图

3.1统计信源熵的设计思路

3.2哈夫曼编码设计思路

四、程序运行及结果

4.1统计信源熵程序运行结果

运行程序并输入:

The most distant way in the world

is not the way from birth to the end.

it is when i sit near you

that you don't understand i love u.

The most distant way in the world

is not that you're not sure i love u.

It is when my love is bewildering the soul

but i can't speak it out.

T测试目的：检验程序是否正确。

检验方法：用验证法来检验；看中概率是否为一，并检测信源熵是否正确。检验结果：程序运行结果正确。

如下为运行结果截屏

4.2哈夫曼编码程序运行结果

测试输入：0.20 0.19 0.18 0.17 0.15 0.10 0.01

测试目的：测试经常出现的信源符号是否对应较短的码长，检测程序运行结果是否正确。

正确输出：10 11 000 001 010 0110 0111

信源熵为-2.60868 bit/符号

平均码长为2.72 码元/符号

传送速率为0.959075 bit/码元

实际输出：与争取而输出一样

检测结果：程序无错误

以下为运行结果截屏

五、心得体会

刚开始课程设计的时候，自己是毫无头绪的，不知道从哪里下手，最重要的原因是对 C 语言没有达到熟练的程度，自己不是很自信。但是万事开头难，什么困难只要踏出第一步，接下来就会一步步化解。

为了更加熟练地用C语言程序进行编写，我与同组成员仔细地复习以前学过的书籍，经过一段时间后对语法的掌握更加地熟练。但是实际上在编写的时候，手打难免会碰到各类的问题，例如忘记在语句后面打“；”

等一系列的小问题，所以自能耐心。对求概率，信源熵，哈夫曼编码的等公式有深入了解后，再构造一个程序的大体框架，再对各个语句的功能进行编写，一步步地完成。运行错误的话要慢慢检查，特别是一些小细节，直到程序完美运行。

尽管在完成设计过程中遇到了很多困难，但是通过自己和同组同学的努力最后还是完成了，不仅对信息论这门课的内容有了更加深入的了解，更增长了自己动手编程的能力。其中我最大的感悟是，学习一门课，要把它学好不仅仅是学懂书上的知识点，书本之外的知识也要掌握，这不是在课堂上就能学会的，要靠自己在课后慢慢地积累。身为大学生的我们把太多时间花在宿舍看电影和玩游戏上面，以至于荒废了太多的时间。对于身处大三的我们来说，剩下的时间尤为重要，若不考研，明年就该找工作了，那时自己身上没一点技能怎能在社会立足。所以我认为现在能做的最近本的就是把本专业的主要内容精髓学好，然后在这个基础上学习一些其他必备的技能。

人的一生就是在不断学习中度过，停止学习就等于与社会隔离，作为大学生就是应该与时俱进奋发图强。以上就是我对这次课程设计真正的感悟。

参考文献

1曹雪虹、张宗橙编著《《信息论与编码》》.清华大学出版社，2009年第2版

2 贾宗璞、许合利编著《《C语言程序设计》》.人民邮电出版社，2010年第1版

3 严蔚敏、吴伟民编著《《数据结构（C语言版）》》.清华大学出版社，1997年第1版

附页，源程序；

一．统计信源熵

#include

#include

void main()

{ double result=0;

int k = 0,a=0,num[26] = {0};

double p[26] = {0};

int j;

char ch;

while((ch=getchar())!='\n')

{

if(ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z')

{

if(ch < 97)

j = ch - 65;

else

j = ch - 97;

num[j]++;

k++;

}

}

printf("各字母出现的次数：\n");

for(int i = 0; i < 26; i++)

{

printf("%c:%d\t", 'A' + i, num[i]);

}

printf("\n字母个数：%d\n", k);

printf("各字母出现的概率：\n");

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

{

printf("%c:%f\t", 'A' + i, (double)num[i]/k);

p[a]=(double)num[i]/k;

a++;

}

printf("\n");

/*******求信源熵*******/

for(a = 0; a < 26; a++)

{if(p[a]!=0)

result=result+p[a]*log(p[a])/log(2);

}

result=-result;

printf("信源熵为:%f",result);

printf("\n");

}

}二、哈夫曼编码程序

/**

file: hoffman coder.c

date: 2015.03.24

describe: 霍夫曼编解码(仅有霍夫曼码元的生成部分)

*/

#include

#include

#include

#include

#define MAX_MESSAGE 1024

#define MAX_MESSAGE_BITS 64

#define DEFAULT_FILE "probability.txt"

struct message_info

{

int a_i; /* 消息符号, a1, a2, a3 .... , 值为唯一的*/

double probability; /* 消息符号对应的概率*/

int father; /* 父节点, 用a_i 表示*/

int left; /* 左子节点, 用a_i 表示*/

int right; /* 子右节点, 用a_i 表示*/

char code[MAX_MESSAGE_BITS]; /* 编码后的hoffman 码值存放在此处*/

};

/* 从文件中读取消息符号概率并存储于struct message_info *message_info 中*/

int hoffman_read_from_file(FILE *fp, struct message_info *message_info);

/* 简单的冒泡排序, 适用于消息种数较少的情况, (n < 10000) */

int bubble_sort(struct message_info **p_message_info, int num);

/* 合并最低的两个符号, 并使总符号数减少1, 以被合并的符号将不再参与合并*/

int hoffman_combine(struct message_info **p_message_info, int message_info_num, int *message_info_pos);

/* 生成hoffman 码*/

int hoffman_create_code(struct message_info *message_info, int message_info_num);

int main()

{

int i, j;

FILE *fp;

struct message_info message_info[MAX_MESSAGE];

struct message_info *p_message_info[MAX_MESSAGE];

struct message_info *find;

int message_info_num, message_info_pos;

double entropy, encoded_efficiency, average_code_length; /* 信源熵, 编码效率和平均编码长度*/

if((fp = fopen(DEFAULT_FILE, "r")) == NULL)

return -1;

else{

message_info_num = hoffman_read_from_file(fp, message_info);

}

average_code_length = encoded_efficiency = entropy = 0.0;

for(j = 0; j < message_info_num; j ++){

entropy += message_info[j].probability * log10(message_info[j].probability) / log10(2);

}

for(j = 0; j < MAX_MESSAGE; j ++){

p_message_info[j] = &message_info[j];

}

message_info_pos = message_info_num;

for(j = 0; j < message_info_num - 1; j ++){

hoffman_combine(p_message_info, message_info_num, &message_info_pos);

bubble_sort(p_message_info, message_info_num + j + 1);

for(i= 0; i < message_info_num - 1 - j; i ++)

printf("a_i = %2d, p = %g\n", i, p_message_info[i] -> probability);

printf("----------------------------------\n");

}

hoffman_create_code(message_info, message_info_num);

printf("\n\ninformation :\n");

for(j = 0; j < 2 * message_info_num - 1; j ++)

printf("a_i = %2d, p = %4.3g, left = %2d, right = %2d, father = %2d, hoffman_code: %s\n", message_info[j].a_i, message_info[j].probability, message_info[j].left, message_info[j].right, message_info[j].father, message_info[j].code);

for(j = 0; j < message_info_num; j ++)

average_code_length += message_info[j].probability * strlen(message_info[j].code);

printf("\n\n## 信源熵为%g\n## 平均编码长度为%g\n## 编码效率为%g\n\n", -entropy, average_code_length, -entropy / average_code_length);

system("pause");

}

/* 从文件中读取消息符号概率并存储于struct message_info *message_info 中*/

int hoffman_read_from_file(FILE *fp, struct message_info *message_info)

{

int count, message_info_pos;

message_info_pos = 0;

while((count = fscanf(fp, "%lf", &(message_info[message_info_pos].probability))) > 0){

message_info[message_info_pos].a_i = message_info_pos; /* a_i 从0 开始*/

message_info_pos ++;

}

return message_info_pos;

}

/* 简单的冒泡排序, 适用于消息种数较少的情况, (n < 10000) */

int bubble_sort(struct message_info **p_message_info, int num)

{

int i, j;

struct message_info *temp;

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

for(j = i + 1; j < num; j ++){

if(p_message_info[i] -> probability < p_message_info[j] -> probability){

temp = p_message_info[i];

p_message_info[i] = p_message_info[j];

p_message_info[j] = temp;

}

}

return 0;

}

/* 合并最低的两个符号, 并使总符号数减少1 */

int hoffman_combine(struct message_info **p_message_info, int message_info_num, int *message_info_pos)

{

/* 从大到小排序*/

bubble_sort(p_message_info, message_info_num * 2 - *message_info_pos);

p_message_info[message_info_num * 2 - *message_info_pos] -> a_i = - (message_info_num - *message_info_pos + 1);

p_message_info[message_info_num * 2 - *message_info_pos] -> code[0] = '\0';

p_message_info[message_info_num * 2 - *message_info_pos] -> probability =

p_message_info[*message_info_pos - 1] -> probability + p_message_info[*message_info_pos - 2] -> probability;

p_message_info[message_info_num * 2 - *message_info_pos] -> left =

p_message_info[*message_info_pos - 1] -> a_i;

p_message_info[message_info_num * 2 - *message_info_pos] -> right = p_message_info[*message_info_pos - 2] -> a_i;

p_message_info[*message_info_pos - 1] -> father = p_message_info[message_info_num * 2 - *message_info_pos] -> a_i;

p_message_info[*message_info_pos - 2] -> father = p_message_info[message_info_num * 2 - *message_info_pos] -> a_i;

(*message_info_pos) --;

return 0;

}

/* 生成hoffman 码*/

int hoffman_create_code(struct message_info *message_info, int message_info_num) {

int i, j, code_num;

char code[MAX_MESSAGE_BITS];

struct message_info *find, *find_father, *find_now;

for(i = 0; i < message_info_num; i ++){

code_num = 0;

find_now = &message_info[i];

while(1){

/* 数字 1.0 代表了所有消息符号概率和, 如果和不为1, 这里需要更改*/

if(fabs(find_now -> probability - 1.0) <= DBL_MIN)

break;

find_father = &message_info[find_now -> father < 0 ? - find_now ->

father + message_info_num - 1 : find_now -> father];

if(find_father -> left == find_now -> a_i)

code[code_num ++] = '1';

else

code[code_num ++] = '0';

find_now = find_father;

}

code[code_num] = '\0';

strrev(code); /* 反转code */

message_info[i].code[0] = '\0';

strcat(message_info[i].code, code);

}

return 0;

}