信息论实验报告.docx

信息论实验报告.docx

《信息论实验报告.docx》由会员分享，可在线阅读，更多相关《信息论实验报告.docx（20页珍藏版）》请在冰豆网上搜索。

信息论实验报告

前言

信息论是现代通信与信息工程的理论基础。

作为电子信息科学与技术专业本科生的学科基础课，本课程主要讲授：

信息的定义和测度、信源和信息熵、连续熵和信息变差、信道和互信息、平均互信息和信道容量、数据处理和信息测量理论、无失真信源编码理论和编码方法等内容。

本课程按“单符号离散信息系统”、“多符号离散信息系统”、“连续信息系统”三个“系统”层面，逐步深入展开，以严密的数学分析贯串始终。

通过教学，使学生掌握信息理论的基本概念和信息分析方法，为今后进一步研究信息科学和信息技术打下坚实的理论基础。

实验一：

唯一可译码判断

实验学时：

3

实验类型：

（演示、验证、综合、√设计、研究）

实验要求：

（√必修、选修）

一、实验目的

通过本次试验了解唯一可译码地判断原理；实现用C语言编写判断唯一可译码地程序

二、实验内容

编程实现唯一可译码的判决准则―――Sardinas－Patterson算法

三、实验原理、方法和手段

Sardinas－Patterson算法描述：

设C为码字集合，按以下步骤构造此码的尾随后缀集合F：

（1）考查C中所有的码字，若Wi是Wj的前缀，则将相应的后缀作为一个尾随后缀放入集合F0中；

（2）考查C和Fi两个集合，若Wj∈C是Wi∈Fi的前缀或Wi∈Fi是Wj∈C的前缀，则将相应的后缀作为尾随后缀码放入集合Fi+1中；

（3）F=∪Fi即为码C的尾随后缀集合；

（4）若F中出现了C中的元素，则算法终止，返回假（C不是唯一可译码）；否则若F中没有出现新的元素，则返回真。

在我们设计的算法中，需要注意的是我们需要的是先输出所有尾随后缀的集合，然后再判断该码是否是唯一可译码，即如F中出现了C中的元素，则C不是唯一可译码，否则若F中没有出现新的元素，则C为唯一可译码。

而不是F中出现C中的元素就终止，这也是在本题的要求中需要注意的问题。

1、概要设计：

由于需要判断尾随后缀，所以我们需要反复的比较C和F中的码字。

1）首先我们用一个b[30][30]的数组来存放所有的尾随后缀的集合；用Q记录所有尾随后缀的个数；

2）用数组a[30][30]来存放输入的码字，L[30]来存放码字的长度；

通过一个双重循环并调用houzhui（a[i],a[j],L[i],L[j]）函数来找到a[30][30]中的为随后缀，即：

for（i=0;i

{

for（j=0;j

{

if（i!

=j&&L[i]

HuoZhui（a[i],a[j],L[i],L[j]）;

}

}

3）通过判断Q是否大于0，如果不大于0，即b[30][30]中没有码字，也就是不存在尾随后缀，那么可判断a[30][30]是唯一可译码，否则进行如下操作；

4）计算b[30][30]中尾随后缀的长度，用k1表示；并调用HuoZhui（b[i],a[j],k1,L[j]）其中k1

for（i=0;i

{

k1=strlen（b[i]）;

for（j=0;j

{

if（k1

HuoZhui（b[i],a[j],k1,L[j]）;

}

}

5）寻找b[30][30]中的尾随后缀；用k2表示b[30][30]中码字的长度，并调用HuoZhui（a[i],b[j],L[i],k2）来实现，其中k2>L[j];通过循环调用即可找到b[30][30]中的所有尾随后缀，最后再将他们分别存放在b[30][30]中；即通过

for（i=0;i

{

for（j=0;j

{

k2=strlen（b[j]）;

if（k2>L[i]）

{

HuoZhui（a[i],b[j],L[i],k2）;

}

}

}

6）在反复调用HuoZhui（a[i],a[j],L[i],L[j]）函数中如果b[30][30]中有重复出现的，即尾随后缀相同的不用再次放入b[30][30]中。

7）在调用函数中所需要注意的问题就是一个比较的问题，也就是实现6）中所提到的。

四，实验数据源

1：

10,0.100

2:

10,110，1110

五、实验组织运行要求

以学生自主训练为主的开放模式组织教学

六、实验条件

1.计算机

2.WindowsXP

3.VC++6.0

七、实验内容

１．实验源程序

#include

#include

#include

structstrings

{

char*string;

structstrings*next;

};

structstringsFstr,*Fh,*FP;

//输出当前集合

voidoutputstr（strings*str）

{

do

{

cout<string<

str=str->next;

}while（str）;

cout<

}

inlineintMIN（inta,intb）

{returna>b?

b:

a;}

inlineintMAX（inta,intb）

{returna>b?

a:

b;}

#definelength_a（strlen（CP））

#definelength_b（strlen（tempPtr））

//判断一个码是否在一个码集合中，在则返回0，不在返回1

intcomparing（strings*st_string,char*code）

{

while（st_string->next）

{

st_string=st_string->next;

if（!

strcmp（st_string->string,code））

return0;

}

return1;

}

//判断两个码字是否一个是另一个的前缀，如果是则生成后缀码

voidhouzhui（char*CP,char*tempPtr）

{

if（!

strcmp（CP,tempPtr））

{

cout<<"集合C和集合F中有相同码字:

"<

<

<<"不是唯一可译码码组!

"<

exit

（1）;

}

if（!

strncmp（CP,tempPtr,MIN（length_a,length_b）））

{

structstrings*cp_temp;

cp_temp=new（structstrings）;

cp_temp->next=NULL;

cp_temp->string=newchar[abs（length_a-length_b）+1];

char*longstr;

longstr=（length_a>length_b?

CP:

tempPtr）;//将长度长的码赋给longstr

//取出后缀

for（intk=MIN（length_a,length_b）;k

cp_temp->string[k-MIN（length_a,length_b）]=longstr[k];

cp_temp->string[abs（length_a-length_b）]=NULL;

//判断新生成的后缀码是否已在集合F里，不在则加入F集合

if（comparing（Fh,cp_temp->string））

{

FP->next=cp_temp;

FP=FP->next;

}

}

}

voidmain（）

{

//功能提示和程序初始化准备

cout<<"\t\t唯一可译码的判断!

\n"<

structstringsCstr,*Ch,*CP,*tempPtr;

Ch=&Cstr;

CP=Ch;

Fh=&Fstr;

FP=Fh;

charc[]="C:

";

Ch->string=newchar[strlen（c）];

strcpy（Ch->string,c）;

Ch->next=NULL;

charf[]="F:

";

Fh->string=newchar[strlen（f）];

strcpy（Fh->string,f）;

Fh->next=NULL;

//输入待检测码的个数

intCnum;

cout<<"输入待检测码的个数:

";

cin>>Cnum;

cout<<"输入待检测码"<

for（inti=0;i

{

cout<

";

chartempstr[10];

cin>>tempstr;

CP->next=new（structstrings）;

CP=CP->next;

CP->string=newchar[strlen（tempstr）];

strcpy（CP->string,tempstr）;

CP->next=NULL;

}

outputstr（Ch）;

CP=Ch;

while（CP->next->next）

{

CP=CP->next;

tempPtr=CP;

do

{

tempPtr=tempPtr->next;

houzhui（CP->string,tempPtr->string）;

}while（tempPtr->next）;

}

outputstr（Fh）;

structstrings*Fbegin,*Fend;

Fend=Fh;

while

（1）

{

if（Fend==FP）

{

cout<<"是唯一可译码码组!

"<

exit

（1）;

}

Fbegin=Fend;

Fend=FP;

CP=Ch;

while（CP->next）

{

CP=CP->next;

tempPtr=Fbegin;

for（;;）

{

tempPtr=tempPtr->next;

houzhui（CP->string,tempPtr->string）;

if（tempPtr==Fend）

break;

}

}

outputstr（Fh）;//输出F集合中全部元素

}

}

２．流程框图

３．数据测试

（１）输入10,0,100

（2）输入10,110，1110

八，实验心得

1.更深入理解了唯一可译码地判断原则

2.学会了用Sardinas－Patterson算法实现编码判断

3.掌握用C编程实现唯一可译码判断

实验二：

Huffman编码的实现

实验学时：

3

实验类型：

（演示、验证、综合、√设计、研究）

实验要求：

（√必修、选修）

一、实验目的

理解和掌握huffman编码的基本原理和方法，实现对信源符号的huffman编码。

二、实验内容

1.理解和掌握huffman编码的基本原理和方法

2.通过MATLAB编程实现对单信源符号的huffma编码

3.计算信源的信息熵、平均码长以及编码效率

三、实验原理

1．Huffman编码按信源符号出现的概率而编码，其平均码长最短，所以是最优码。

2．无失真信源编码定理：

对于熵为H（X）的离散无记忆的平稳信源，必存在一种无失真编码，使每符号的平均码长满足不等式：

3．二元Huffman编码：

若将编码设计为长度不等的二进制编码，即让待传字符串中出现概率大的字符采用尽可能短的码字，而把长的码字分配给概率小的信源符号。

构造方法如下：

（a）将信源概率分布按大小以递减次序排列；合并两概率最小者，得到新信源；并分配0/1符号。

（b）新信源若包含两个以上符号返回（a），否则到（c）。

（c）从最后一级向前按顺序写出每信源符号所对应的码字。

4．Huffman编码算法

ProcedureHUFFMAN（{si},{pi}）

ifq==2then

returns0→0,s1→1

else

降序排序{pi}

缩减信源:

创建一个符号s′以取代sq-2,sq-1,其概率为p′=pq-2+pq-1

递归调用Huffman算法以得到s0,…,sq-3,s′的编码:

w0,…,wq-3,w′,相应的概率分布为p0,…,pq-3,p′

Returns0→w0,…,sq-3→wq-3,sq-2→w′0,sq-1→w′1

endif

endprocedure

四、实验数据源

1．

2．

五、实验组织运行要求

以学生自主训练为主的开放模式组织教学

六、实验条件

4.计算机

5.WindowsＸＰ

6.VC++6.0

七、实验内容

１．实验源程序

#include

#defineMAXBIT100

#defineMAXVALUE10000

#defineMAXLEAF30

#defineMAXNODEMAXLEAF*2-1

typedefstruct

{

intbit[MAXBIT];

intstart;

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

typedefstruct

{

intweight;

intparent;

intlchild;

intrchild;

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

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

voidHuffmanTree（HNodeTypeHuffNode[MAXNODE],intn）

{

/*i、j：

循环变量，m1、m2：

构造哈夫曼树不同过程中两个最小权值结点的权值，

x1、x2：

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

*/

inti,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;

}/*endfor*/

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

for（i=0;i

{

printf（"Pleaseinputweightofleafnode%d:

\n",i）;

scanf（"%d",&HuffNode[i].weight）;

}/*endfor*/

/*循环构造Huffman树*/

for（i=0;i

{

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

x1=x2=0;

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

for（j=0;j

{

if（HuffNode[j].weight

{

m2=m1;

x2=x1;

m1=HuffNode[j].weight;

x1=j;

}

elseif（HuffNode[j].weight

{

m2=HuffNode[j].weight;

x2=j;

}

}/*endfor*/

/*设置找到的两个子结点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.weightandx2.weightinround%d:

%d,%d\n",i+1,HuffNode[x1].weight,HuffNode[x2].weight）;/*用于测试*/

printf（"\n"）;

}/*endfor*/

}/*endHuffmanTree*/

intmain（void）

{

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

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

inti,j,c,p,n;

printf（"Pleaseinputn:

\n"）;

scanf（"%d",&n）;

HuffmanTree（HuffNode,n）;

for（i=0;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;/*设置下一循环条件*/

}/*endwhile*/

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

for（j=cd.start+1;j

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

HuffCode[i].start=cd.start;

}/*endfor*/

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

for（i=0;i

{

printf（"%d'sHuffmancodeis:

",i）;

for（j=HuffCode[i].start+1;j

{

printf（"%d",HuffCode[i].bit[j]）;

}

printf（"\n"）;

}

return0;

}

2.流程框图

3.数据测试

（1）

（2）

八．实验心得

1.更深入了解了哈夫曼编码的构造原理

2.同本次试验学会了利用构造哈弗曼树实现哈夫曼编码

3.掌握用C编程实现哈夫曼编码