信息论课程设计

电子科技大学电子工程学院信息论课程设计报告课程名称：信息编码与加密

课程设计报告

学生姓名：农瀚学号：2014020908021 指导教师：李万春

一、课程设计名称：编程实现霍夫曼、费诺、香农编码

二、课设原理：

1）霍夫曼编码：霍夫曼编码的平均码长最短，是最佳编码。编码步骤如下：

（1）将信源符号按概率大小排序；

（2）对概率最小的两个符号求其概率之和，同时给两幅

号分别赋予码元0和1；

（3）将概率之和当做一个新符号的概率。与剩下的概率一起，形成一个缩减信源，再重复上述步骤，直到概率和为1为止；（4）按上述步骤实际上构成了一个码树，从根到端点经过的树枝即为码字。

2）费诺编码：

编码步骤如下：

（1）将信源概率从大到小排序；

（2）将信源符号分成两组，使两组信源符号的概率之和近似相等，并给两组信源符号分别赋0和1；

（3）再把各个小组的信源符号细分为两组并赋码元，方法与第一次分组相同；

（4）如此一直下去，直到每一个小组只含一个信源符号为止；（5）由此可构造成一个码树，所有终端节点上的码字组成费诺码。

3）香农编码：

编码方法如下：

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

p(u1)≥p(u2)≥…≥p(un)

⑵确定码长Ki (整数) ：

Ki= []——取整

⑶为了编成唯一可译码，计算第i个消息的累加概率

⑷将累加概率Pi变换成二进制数。

⑸取pi二进制数的小数点后Ki位即为该消息符号的二进制数。

三、课设目的：通过编程实现三种方式的编码，掌握三种编

码方式的步骤。

四、课设内容：

三种编码方式的编程思路：

1、霍夫曼编码：（1）对给定的n个权值{W1,W2,W3,...,Wi,...,Wn}构成n棵二叉树的初始集合F= {T1,T2,T3,...,Ti,...,Tn}，其中每棵二叉树Ti中只有一个权值为Wi的根结点，它的左右子树均为空。（为方便在计算机上实现算法，一般还要求以Ti的权值Wi的升序排列。）

（2）在F中选取两棵根结点权值最小的树作为新构造的二叉树的左

右子树，新二叉树的根结点的权值为其左右子树的根结点的权值之和。

（3）从F中删除这两棵树，并把这棵新的二叉树同样以升序排列加入到集合F中。

（4）重复二和三两步，直到集合F中只有一棵二叉树为止。

2、费诺编码的编程思路：（1）先使用冒泡法对信源概率概率排序；（2）依次将按排好序的符号概率进行近似1:1分成两大组；

（3）对各组赋予一个二进制码元“0”和“1”；

（4）输出符号,符号概率及编码。

3、香农编码：

（1）对于一个给定的符号列表，制定了概率相应的列表或频率计数，使每个符号的相对发生频率是已知。

（2）排序根据频率的符号列表，最常出现的符号在左边，最少出现的符号在右边。

（3）清单分为两部分，使左边部分的总频率和尽可能接近右边部分的总频率和。

（4）该列表的左半边分配二进制数字0，右半边是分配的数字1。这意味着，在第一半符号代都是将所有从0开始，第二半的代码都从1开始。

（5）对左、右半部分递归应用步骤3和4，细分群体，并添加位的代码，直到每个符号已成为一个相应的代码树的叶。

五、器材（设备、元器件）：

计算机、visual studio2017社区版

六、设计代码：见附录

九、实验数据及结果

根据上述实验程序得到的实验数据及结果如下：霍夫曼编码：

费诺编码：

香农编码：

十、结论

完成了20个非等概随机信源的霍夫曼、费诺和香农编码，并给出了编码效率和码字。

十一、总结及心得体会

通过这次课程设计，我掌握了三种编码方式的步骤，并能够利用编程实现编码，提高了自己的编程水平和对该知识点的掌握程度。

附录代码：

// ConsoleApplication1.cpp : 定义控制台应用程序的入口点。

//

/*******霍夫曼编码*************/

#include"stdafx.h"

#include

#include

#include

#include

#include

#include

using namespace std;

#define SourNum 20

#define MAXBIT 100

#define MaxValue 10000

#define MAXLEAF 30

#define MAXNODE MAXLEAF*2 -1

double Sp[SourNum];

char coder[100][100];

int bitlong[100];

void ProSource()//产生非等概信源的函数

{

int n = 0;

srand((unsigned)time(0));

double sum = 0;

while (1)

{

Sp[n] = (double)rand() / (RAND_MAX);//产生随机浮点数

sum = sum + Sp[n];

if (sum < 1 && Sp[n] <0.086)

{

n++;

if (n >19)

break;

else continue;

}

else

{

sum = sum - Sp[n];

Sp[n] = 0;

continue;

}

}

Sp[SourNum] = 1 - sum;

}

/*******霍夫曼编码*************/

typedef struct

{

int bit[MAXBIT];

int start;

} HCode;

typedef struct

{

double weight;

double parent;

double lchild;

double rchild;

int last;

} HNodeType;

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

{

int i, j, x1, x2;;

double m1, m2;

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

{

HuffNode[i].weight = 0;

HuffNode[i].parent = -1;

HuffNode[i].lchild = -1;

HuffNode[i].rchild = -1;

}

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

{

HuffNode[i].weight = Sp[i];

}

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

{

m1 = m2 = MaxValue;

x1 = x2 = 0;

for (j = 0; j < n + i; 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;

}

}

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;

}

}

double CodEffi()//求编码效率

{

int AveraLong = 0, SumLong = 0;

double H = 0, CE = 0;

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

{

SumLong = SumLong + bitlong[i];

}

AveraLong = SumLong / SourNum;

for (int j = 0; j < SourNum; j++)

{

H = (-Sp[j])*(log(Sp[j]) / log(2)) + H;

}

CE = H / AveraLong;

return CE;

}

int main()

{

ProSource();

sort(Sp, Sp + SourNum);

HNodeType HuffNode[MAXNODE];

HCode HuffCode[MAXLEAF], cd;

int i, j, c, p, n;

n = SourNum;

HuffmanTree(HuffNode, SourNum + 1);

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;

}

for (j = cd.start + 1; j

{

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

}

HuffCode[i].start = cd.start;

}

memset(coder, '\0', sizeof(coder));

int temp=0;

for (i = 0; i

{

cout <<"信源 "<< i <<"编码为：";

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

{

cout << HuffCode[i].bit[j];

coder[i][temp]= char(HuffCode[i].bit[j]+48);

temp++;

}

temp = 0;

cout <<" 信源概率："<< Sp[i];

cout <<" 字长："<< strlen(coder[i]);

printf("\n");

bitlong[i] = strlen(coder[i]);

}

CodEffi();

cout <<"\n编码效率: "<< CodEffi() * 100 <<"%\n";

return 0;

}

// 费诺编码.cpp : 定义控制台应用程序的入口点。

//

#include"stdafx.h"

#include

#include

#include

#include

#include

#include

#include

#define Bmax 10 #define Smax 20

using namespace std;

#define SourNum 20

double Sp[SourNum];

int bitlong[100];

void group1(int low, int mid, int high);

void code(int low, int mid, int high);

void ProSource()//产生非等概信源的函数

{

int n = 0;

srand((unsigned)time(0));

double sum = 0;

while (1)

{

Sp[n] = (double)rand() / (RAND_MAX);//产生随机浮点数

sum = sum + Sp[n];

if (sum < 1 && Sp[n] <0.086) //

{

n++;

if (n >19)

break;

else continue;

}

else

{

sum = sum - Sp[n];

Sp[n] = 0;

continue;

}

}

Sp[SourNum] = 1 - sum;

}

struct Bit

{

char b[Bmax]; //定义码长度数组的数据类型字符型组成成员int last;

};

typedef struct symbol

{

int c;

double probability;

struct Bit bit;

}sbl;

sbl s[Smax];

/********输入符号的符号概率********/

void input(int n)

{

int i;

int c;

for (i = 0; i

{

s[i].c = i;

s[i].probability = Sp[i];

}

}

/***********用冒泡法排序**********/

void code(int low, int mid, int high)

{

int i;

for (i = low; i

{

if (i

{

s[i].bit.b[s[i]https://www.360docs.net/doc/c511626632.html,st] = '0';

s[i]https://www.360docs.net/doc/c511626632.html,st++;

}

else

{

s[i].bit.b[s[i]https://www.360docs.net/doc/c511626632.html,st] = '1';

s[i]https://www.360docs.net/doc/c511626632.html,st++;

}

}

}

void sort(int n)

{

double t;

char a;

int i, j;

for (i = 1; i

for (j = 0; j

if (s[j].probability

{

t = s[j].probability;

a = s[j].c;

s[j].probability = s[j + 1].probability;

s[j].c = s[j + 1].c;

s[j + 1].probability = t;

s[j + 1].c = a;

}

}

/************分组函数************/

void group(int n)

{

int i, pmid, plow, phigh;

pmid = phigh = n;

plow = 0;

for (i = 0; i

group1(plow, pmid, phigh);

}

void group1(int low, int mid, int high)

{

double d, dmin;

d = 0;

int i;

if (high == low + 1)

return;

for (i = low; i

d += s[i].probability;

dmin = d - 2 * s[low].probability;

for (i = low + 1; i

{

d = fabs(dmin - 2 * s[i].probability);

if (d

dmin = d;

else

break;

}

mid = i;

code(low, mid, high);

group1(low, mid, mid);

group1(mid, high, high);

}

void output(int n)

{

int i, j;

printf("费诺编码输出信源,概率及编码：\n\n");

for (i = 0; i

{

cout<<"信源："<

for (j = 0; j

cout<< s[i].bit.b[j];

bitlong[i] = s[i]https://www.360docs.net/doc/c511626632.html,st;

cout <<" "<<"字长"<< bitlong[i];

printf("\n");

}

}

double CodEffi( )

{

int AveraLong =0,SumLong=0;

double H=0,CE=0;

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

{

SumLong = SumLong + bitlong[i];

}

AveraLong = SumLong / SourNum;

for (int j=0; j < SourNum; j++)

{

H = (-Sp[j])*(log(Sp[j]) / log(2)) + H;

}

CE = H / AveraLong;

return CE;

}

void main() //主函数

{

int n = SourNum; //定义变量

ProSource();

input(n); //分别调用输入、排序、分组、输出函数，并执行

sort(n);

group(n);

output(n);

cout <<"\n编码效率: "<< CodEffi() * 100 <<"%\n";

}

// 香农编码.cpp : 定义控制台应用程序的入口点。

//

#include"stdafx.h"

#include

#include

#include

#include

#include

#include

#include

#include

#define Bmax 10 //最长码长度#define Smax 20

using namespace std;

#define SourNum 20

double Sp[SourNum];

int bitlong[100];

struct shan

{

int s;

double p;

double padd;

double l_f;

int l;

char w[20];

};

shan SourData[SourNum];

void group1(int low, int mid, int high);

void code(int low, int mid, int high);

void ProSource()//产生非等概信源的函数

{

int n = 0;

srand((unsigned)time(0));

double sum = 0;

while (1)

{

Sp[n] = (double)rand() / (RAND_MAX);//产生随机浮点数

sum = sum + Sp[n];

if (sum < 1 && Sp[n] <0.086) //

{

n++;

if (n >19)

break;

else continue;

}

else

{

sum = sum - Sp[n];

Sp[n] = 0;

continue;

}

}

Sp[SourNum] = 1 - sum;

}

int i, j, n, k, b;

double addp;

char bitw[20];

void sequ(struct shan x[], int n)

{

struct shan temp;

for (i = 0; i

for (j = i; j

{

if (x[i].p

{

temp =x[j];

x[j] =x[i];

x[i] = temp;

}

}

}

void countpadd(struct shan x[], int n) {

addp = 0;

x[0].padd = 0;

for (i = 0; i

{

addp += x[i].p;

x[i + 1].padd = addp;

}

void count_l(struct shan x[], int n)

{

for (i = 0; i

{

x[i].l_f = -log(x[i].p) / log(2);

if ((x[i].l_f - (int)x[i].l_f)>0)

x[i].l = (int)x[i].l_f + 1;

else x[i].l = (int)x[i].l_f;

}

}

void covbit(double a, int lc)

{

for (j = 0; j

{

b = (int)(a * 2);

bitw[j] = b + 48;

a = 2 * a - int(a * 2);

}

}

double CodEffi()

{

int AveraLong = 0, SumLong = 0;

double H = 0, CE = 0;

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

{

SumLong = SumLong + bitlong[i];

}

AveraLong = SumLong / SourNum;

for (int j = 0; j < SourNum; j++)

{

H = (-Sp[j])*(log(Sp[j]) / log(2)) + H;

}

CE = H / AveraLong;

return CE;

}

int main()

{

n = SourNum;

ProSource();

for (i = 0; i

{

SourData[i].s= i;

/*获取信源概率*/

for (i = 0; i

{

SourData[i].p=Sp[i];

}

sequ(SourData, n);

countpadd(SourData, n);

count_l(SourData, n);

for (i = 0; i

{

covbit(SourData[i].padd, SourData[i].l);

strcpy(SourData[i].w, bitw);

}

/*输出数据*/

cout.fill(' ');

for (i = 0; i

cout << left << setw(6) <<"信源符号： "<< SourData[i].s<<" 信源概率：

"<

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

{

bitlong[i] = SourData[i].l;

}

cout <<"\n编码效率: "<< CodEffi() * 100 <<"%\n";

return 0;

}