图论及其应用期末论文

在通信领域中，传输信息的方法有两种，其一是等长码制方法，其二是非等长码制方式；字符出现的频率不同,在传输中采用非等长二进制编码传输会提高传输效率,在字符的出现频率已知前提下,采用最优二叉正则树算法,可以得到最佳前缀码。

关键字正则二叉树 前缀码 最优二叉树 哈夫曼编码 频率 java 程序

引言

在通信中,通常采用二进制编码表示符号,如果每个要传输的符号使用频率相同,则采用等长码表示即可,但事实上不同符号在传输过程中出现的频率并不相同,有些符号出现频率相差很大,此时采用非等长编码可节省二进制数位,可达到提高效率的目的。

相关基础知识

下面介绍有关二叉树以及哈夫曼编码的相关知识：

定义1：一个有向图，若不考虑他的方向，他是一棵树，则称这个有向图为有向树。一颗有向树，如果恰有一个结点的入度为0，其余所有结点的入度都为1，则称为根树，其中入度为0的结点称为树根，出度为0的结点称为树叶，出度不为0的结点称为分支点或内点。

在根树中，称从树根到结点v 的距离称为该点的层次。

定义2：在根树中，若从i v 到

j v 可达，则称i v 是j v 的祖先，j v 是i v 的后代，又若),(j i v v 是树根中的有向边，则称i v 是j v 的父亲，j v 是i v 的儿子；如果两个结点是同一结点的儿子，则称这两个结点是兄弟。

定义3：在根树中，任一结点v 及其v 的后代和从v 出发的所有有向路中的边构成的子图称为以v 为根的子路，根树中的结点u 的子树是以u 的儿子为根的子树。 定义4：如果在根树中规定了每一层次上结点的次序，这样的根树称为有序树。在有序树中规定了同一层次结点的次序是从左至右。

定义5：一个有向图，如果他的每个连通分支是有向树，则称该有向图为森林；在森林中，如果所有树都是有序树且给树指定了次序，则称此森林为有序森林。

在树的实际应用中，我们经常用到m 叉树。

定义6：在根树T 中，若结点的最大出度为m ，则称T 为m 叉树，如果T 的每个分支点的出度都恰好等于m ，则称T 为m 叉树。若完全m 叉树的所有叶结点在同一层，则称他为正则m 叉树。二叉树的每个结点v 至多有两颗子树，分别称为v 的左子树和右子树。若结点v 只有一颗子树，则称他为v 的左子树或右子树均可。若T 是正则m 叉树，并且是有序树，则称T 为m 元有序树。

简单来讲：

二叉树的定义[1]：二叉树是结点的有限集合且集合是有限的，这个集合要么为空，要么是由一个根结点和不相交的左、右子树构成。

二叉树的特性[2]：在二叉树中每个结点最多只能有两个孩 子，分别是这个结点的左孩子和右孩子，这一点也说明了在二叉 树中结点的度没有大2的，并且特别注意二叉树的左子树、右子树的次序是不能颠倒的。

定义7：设有一颗二叉树，有t 片树叶，使其树叶分别带权t ωωω ，

，21的二叉树称为带权二叉树。

定义8：设有一颗带权t ωωω ，

，21的二叉树T ，其权为i ω的树叶的层数为)(i L ω 该带权二叉树的权为W(T)定义为

∑==t i i i L T W 1)

()(ωω

在所有带权t ωωω ，

，21的二叉树中，)(T W 最小的树称为最优二叉树。 哈夫曼树的有关知识

哈夫曼编码（Huffman Coding ）是一种编码方式，并且是可变字长编码。它是在 1952年由 David A.Huffman 提出的，这种编码方式发表于《一种构建极小多余编码的方法》一文。 哈夫曼编码是一种用于无损数据压缩的权编码算法，即在计算机的数据处理中，哈夫曼编码使用的是一种变长的编码表对源文件（如文件的一个字母）进行编码，其中变长编码就是通过评估源符号出现的机率得到的。并且出现次数较高的字母使用较短的编码，出现次数较低的字母则使用较长的编码，这样就使得编码之后的字符串的平均长度和期望值大大降低，从而达到节约内存、提高 执行效率的目的。这个编码需要我们先建立一个哈夫曼树（关

键部分），哈夫曼树建立以后从根结点到各个叶子结点的左分支为0，右分支为 1，然后从上到下依次写出每个结点的哈弗曼编码。哈夫曼树：假设有t 个权值t ωωω ，，21，并且由这些权值按照一定的规则构造一棵共有t 个叶子结点的二叉树，并且每一个叶子结点都对应一个权值 ，经过计算带权路径长度W(T)最小的二叉树就是哈夫曼树。 由于哈夫曼树是最优二叉树，故哈夫曼树同样必须满足二叉树的特点。

Huffman 算法

（1）给定权重序列t ωωω ，

，21，且t ωωω≤≤≤ 21。 （2）连接权为21ωω，的两片树叶，得一个分支点其权为21ωω+；

在21ωω+t ωωω，，，，

43中选择两个中最小的权，连接他们对应的结点（不一定是树叶），得新分支点及所带的权；

（3）重复（2），直到形成t-1个分支点，t 片树叶为止。

用一个例子来理解一下以上概念

给定4个叶子结点a ，b ，c 和d ，分别带权7，5，2和4。构造如下图所示的三棵二叉树(还有许多棵)，它们的带权路径长度分别为：

18 18 18

(a) (b) (c) (a)3624222527)(=?+?+?+?=T W

(b)4624123537)(=?+?+?+?=T W

(c)3534322517)(=?+?+?+?=T W

其中(c)树的)(T W 最小，可以验证，它就是哈夫曼树。

注意：

① 叶子上的权值均相同时，完全二叉树一定是最优二叉树，否则完全二叉树不一定是最优二叉树。

② 最优二叉树中，权越大的叶子离根越近。

③ 最优二叉树的形态不唯一，)(T W 最小

利用Huffman 算法求解

用带叶权的最优二叉树算法,根据每个符号(或字母)出现的频率作为叶权去求解。

以一个实例综合说明该问题:

已知通信中,八进制数字(0,1,2,3,4,5,6,7)出现的频率如下:

0:25%, 1:20%, 2:15%, 3:10%

4:10%, 5:10%, 6:5%, 7:5%

试求传输它们的最佳前缀码,并讨论传输10000个按以上比例出现的八进制数字7 6 12 14 4 5 2 4 2 12 5 7 7 11 4 2 5 6

需要多少个二进制数字?若用等长为3的码子传愉需要多少个二进制数字?

解:为方便计,设传输100个按以上频率出现的八进制数字(即乘以100倍)权值依次为 w1=5, w2=5, w3=10, w4=10,

w5=10, w6=15, w7=20, w8=25,

用Huffman 算法求最优树（Java ）

Huffman 算法求最优二叉树

10传0; 111传1; 110传2; 000传3;

001传4; 010传5 0110传6 0111传7

8个码子的前缀码为{10，111，110，000，001，010，0110，0111}最佳

10 40 100 10 60 20 5

20 5 35 25 10 10 20 15

2853203152)45(3)310()(=?+?+??+??=T W

说明传送100个题中给的频率出现的数字,需285个

二进制数字。同理,传输10000个八进制数字需要用28500285010=?个二进制数字。

若用3位(0或1）等长码传输:

000-0 001-1 010-2 011-3

100-4 101-5 110-6 111-7

则传10000个八进制数字要用30000个二进制数字。

使用前缀码提高了效率:%5%100300002850030000=?-

另外,顶点所放位置不同,最小权选法不同,得到的最优树也可能不同,也可能根本不同构,但有一点是共同的:权W(T)应相同,即是最优树,故得到前缀码不唯一。

结束语

伴随计算机网络与通信技术的发展,信息传输量愈来愈大,采用科学高效的编码方式传输,将极大提高传输效率,实现高速低耗的目的。

参考文献

[1] 张清华，陈六新，李永红.图论及其应用[M].清华大学出版社，2012.12：77-84.

[2]陈桂英，王亚鹏.哈夫曼树及其应用[J].Journal of Henan Science and Technology,2014.11:256-257.

[3] 任正云.哈夫曼树的构造及其在信息编码中的应用[J].沙洋师范高等专科学校学报,2007.11:31-32

[4] 叶明凤，苏慧郝，维来.最优二叉树在通信编码中的应用[J].鸡西大学学报，2001.3：59-60.

[5] 李云鹤，武善玉，钟鸣.最优二叉树编译码确定的一种新方法[J].茂名学院学报，2003.11：43-44.

[6] 张广学.最优二叉树的生成及应用[J].陕西纺织服装职业技术学院,2008.10:112-113

[7] 刘奇超.赫夫曼编码及其应用[J].郑州市电子信息工程学校.

[8]https://www.360docs.net/doc/8e16191801.html,/link?url=Cc0qf-kk2CN2-9dQ1AQqfEEervS4FS6wVJWIwxmX16K ScOy_o9dyMHr2JUsbEuKebYSm2CECZLuk8gU_ITqLhk5tfhZ5GWT-tReTu_60vzS

[9] https://www.360docs.net/doc/8e16191801.html,/csh624366188/article/details/7520997

附：Huffman算法java实现源程序

class Code

{ //哈夫曼编码类

int[] bit; //数组

int start; //编码的起始下标

int weight; //字符的权值

public Code(int n)

{

bit = new int[n];

start = n - 1;

}

}

class HaffNode

{ //哈夫曼树的结点类

int weight; //权值

int flag; //标记

int parent; //双亲结点下标

int leftChild; //左孩子下标

int rightChild; //右孩子下标

public HaffNode()

{

}

}

class HaffmanTree

{

static final int maxValue = 10000; //最大权值

private int nodeNum; //叶结点个数

public HaffmanTree(int n)

{

nodeNum = n;

}

public void haffman(int[] weight, HaffNode[] node)

{

//构造权值为weight的哈夫曼树haffTree

int m1, m2, x1, x2;

int n = nodeNum;

//哈夫曼树haffTree初始化。n个叶结点的哈夫曼树共有2n-1个结点for(int i = 0; i < 2 * n - 1; i ++)

{

HaffNode temp = new HaffNode();

if(i < n)

temp.weight = weight[i];

else

temp.weight = 0;

temp.parent = 0;

temp.flag = 0;

temp.leftChild = -1;

temp.rightChild = -1;

node[i] = temp;

}

//构造哈夫曼树haffTree的n-1个非叶结点

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

{

m1 = m2 = maxValue;

x1 = x2 = 0;

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

{

if(node[j].weight < m1 && node[j].flag == 0)

{

m2 = m1;

x2 = x1;

m1 = node[j].weight;

x1 = j;

}

else if(node[j].weight < m2 && node[j].flag == 0)

{

m2 = node[j].weight;

x2 = j;

}

}

//将找出的两棵权值最小的子树合并为一棵子树

node[x1].parent = n+i;

node[x2].parent = n+i;

node[x1].flag = 1;

node[x2].flag = 1;

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

node[n+i].leftChild = x1;

node[n+i].rightChild = x2;

}

}

public void haffmanCode(HaffNode[] node, Code[] haffCode)

{

//由哈夫曼树haffTree构造哈夫曼编码haffCode

int n = nodeNum;

Code cd = new Code(n);

int child, parent;

//求n个叶结点的哈夫曼编码

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

{

cd.start = n - 1; //不等长编码的最后一位为n-1

cd.weight = node[i].weight; //取得编码对应的权值

child = i;

parent = node[child].parent;

while(parent != 0)

{

//由叶结点向上直到根结点循环

if(node[parent].leftChild == child)

cd.bit[cd.start] = 0; //左孩子结点编码0

else

cd.bit[cd.start] = 1; //右孩子结点编码1

cd.start --;

child = parent;

parent = node[child].parent;

}

Code temp = new Code(n);

//保存叶结点的编码和不等长编码的起始位

for(int j = cd.start+1; j < n; j++)

temp.bit[j] = cd.bit[j];

temp.start = cd.start;

temp.weight = cd.weight;

haffCode[i] = temp;

}

}

}

public class Exam

{

public static void main(String[] args)

{

int n = 8;

HaffmanTree myHaff = new HaffmanTree(n);

int[] weight = {5,5,10,10,10,15,20,25};

HaffNode[] node = new HaffNode[2 * n + 1];

Code[] haffCode = new Code[n];

myHaff.haffman(weight, node);

myHaff.haffmanCode(node, haffCode);

//输出每个叶结点的哈夫曼编码

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

{

System.out.print("Weight = " + haffCode[i].weight + " Code = ");

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

System.out.print(haffCode[i].bit[j]);

System.out.println();

}

}

}