哈夫曼树及其操作-数据结构实验报告(2)
数据结构哈夫曼树实验报告

数据结构哈夫曼树实验报告一、实验目的本次实验的主要目的是深入理解和掌握哈夫曼树的数据结构及其相关算法,通过实际编程实现哈夫曼编码和解码的过程,提高对数据结构的应用能力和编程技能。
二、实验环境本次实验使用的编程语言为 Python,开发工具为 PyCharm。
操作系统为 Windows 10。
三、实验原理哈夫曼树(Huffman Tree),又称最优二叉树,是一种带权路径长度最短的二叉树。
其基本思想是通过构建一棵二叉树,使得权值较大的节点离根节点较近,权值较小的节点离根节点较远,从而实现带权路径长度的最小化。
哈夫曼编码是一种基于哈夫曼树的变长编码方式。
对于给定的字符集及其出现的频率,通过构建哈夫曼树,可以为每个字符生成唯一的编码,使得编码后的字符串总长度最短。
在构建哈夫曼树的过程中,首先将每个字符及其出现的频率作为一个独立的节点,然后按照频率从小到大的顺序进行合并,每次合并两个频率最小的节点,生成一个新的节点,其频率为两个子节点频率之和。
重复这个过程,直到所有节点合并为一个根节点,最终得到的二叉树即为哈夫曼树。
四、实验步骤1、定义节点类```pythonclass Node:def __init__(self, char, freq, left=None, right=None):selfchar = charselffreq = freqselfleft = leftselfright = rightdef __lt__(self, other):return selffreq < otherfreq```这个节点类包含了字符、频率以及左右子节点的信息,并实现了小于比较方法,以便在构建哈夫曼树时进行节点的排序。
2、构建哈夫曼树```pythondef build_huffman_tree(freq_dict):nodes = Node(char, freq) for char, freq in freq_dictitems()while len(nodes) > 1:nodessort()left = nodespop(0)right = nodespop(0)merged_freq = leftfreq + rightfreqnew_node = Node(None, merged_freq, left, right)nodesappend(new_node)return nodes0```该函数根据字符频率字典创建节点列表,然后不断合并频率最小的两个节点,直到只剩下一个节点,即哈夫曼树的根节点。
哈夫曼树_实验报告

一、实验目的1. 理解哈夫曼树的概念及其在数据结构中的应用。
2. 掌握哈夫曼树的构建方法。
3. 学习哈夫曼编码的原理及其在数据压缩中的应用。
4. 提高编程能力,实现哈夫曼树和哈夫曼编码的相关功能。
二、实验原理哈夫曼树(Huffman Tree)是一种带权路径长度最短的二叉树,又称为最优二叉树。
其构建方法如下:1. 将所有待编码的字符按照其出现的频率排序,频率低的排在前面。
2. 选择两个频率最低的字符,构造一棵新的二叉树,这两个字符分别作为左右子节点。
3. 计算新二叉树的频率,将新二叉树插入到排序后的字符列表中。
4. 重复步骤2和3,直到只剩下一个节点,这个节点即为哈夫曼树的根节点。
哈夫曼编码是一种基于哈夫曼树的编码方法,其原理如下:1. 从哈夫曼树的根节点开始,向左子树走表示0,向右子树走表示1。
2. 每个叶子节点对应一个字符,记录从根节点到叶子节点的路径,即为该字符的哈夫曼编码。
三、实验内容1. 实现哈夫曼树的构建。
2. 实现哈夫曼编码和译码功能。
3. 测试实验结果。
四、实验步骤1. 创建一个字符数组,包含待编码的字符。
2. 创建一个数组,用于存储每个字符的频率。
3. 对字符和频率进行排序。
4. 构建哈夫曼树,根据排序后的字符和频率,按照哈夫曼树的构建方法,将字符和频率插入到哈夫曼树中。
5. 实现哈夫曼编码功能,遍历哈夫曼树,记录从根节点到叶子节点的路径,即为每个字符的哈夫曼编码。
6. 实现哈夫曼译码功能,根据哈夫曼编码,从根节点开始,按照0和1的路径,找到对应的叶子节点,即为解码后的字符。
7. 测试实验结果,验证哈夫曼编码和译码的正确性。
五、实验结果与分析1. 构建哈夫曼树根据实验数据,构建的哈夫曼树如下:```A/ \B C/ \ / \D E F G```其中,A、B、C、D、E、F、G分别代表待编码的字符。
2. 哈夫曼编码根据哈夫曼树,得到以下字符的哈夫曼编码:- A: 00- B: 01- C: 10- D: 11- E: 100- F: 101- G: 1103. 哈夫曼译码根据哈夫曼编码,对以下编码进行译码:- 00101110111译码结果为:BACGACG4. 实验结果分析通过实验,验证了哈夫曼树和哈夫曼编码的正确性。
(完整word版)哈夫曼树实验报告

实验报告1、实验目的:(1)理解哈夫曼树的含义和性质。
(2)掌握哈夫曼树的存储结构以及描述方法。
(3)掌握哈夫曼树的生成方法。
(4)掌握哈夫曼编码的一般方法,并理解其在数据通讯中的应用.2、实验内容:哈夫曼树与哈弗曼编码、译码a。
问题描述:哈夫曼问题的提出可以参考教材P。
145。
利用哈弗曼编码进行通信可以大大提高通信利用率,缩短信息传输时间,降低传输成本。
但是,这要求在发送端通过一个编码系统对待传数据预先编码,在接收端将传来的数据进行译码.b。
算法提示:参见教材P.147—148算法6.12、6。
13的描述.3、实验要求:建立哈夫曼树,实现编码,译码。
错误!.初始化(Initialization)。
从终端读入字符集大小n,以及n个字符和n个权值,建立哈夫曼树,并将它存于文件hfmTree中。
○2。
编码(Encoding).利用已建好的哈夫曼树(如不在内存,则从文件hfmTree中读入),对文件ToBeTran 中的正文进行编码,然后将结果存入文件CodeFile中。
○3.译码(Decoding ).利用已建好的哈夫曼树将文件CodeFile中的代码进行译码,结果存入文件T extFile 中。
错误!.输出代码文件(Print).将文件CodeFile以紧凑格式显示在终端上,每行50个代码。
同时将此字符形式的编码文件写入文件CodePrint中。
错误!。
输出哈夫曼树(TreePrinting).将已在内存中的哈夫曼树以直观的方式(树或凹入表形式)显示在终端上,同时将此字符形式的哈夫曼树写入文件TreePrint中。
测试数据:设权值c= (a,b, c, d , e, f,g,h)w=(5,29,7,8,14,23,3,11),n=8。
按照字符‘0’或‘1’确定找左孩子或右孩子,则权值对应的编码为:5:0001,29:11,7:1110,8:111114:110,23:01,3:0000,11:001。
数据结构哈夫曼树的实验报告

软件学院设计性实验报告理解哈夫曼树的特征及其应用;在对哈夫曼树进行理解的基础上,构造哈夫曼树,并用构造的哈夫曼树进行编码和译码;通过该实验,使学生对数据结构的应用有更深层次的理解。
二、实验仪器或设备学院提供公共机房,1台/学生微型计算机。
三、总体设计(设计原理、设计方案及流程等)1.问题描述:利用哈夫曼编码进行通信可以大大提高信道利用率,缩短信息传输时间,降低传输成本。
但是,这要求在发送端通过一个编码系统对待传数据预先编码,在接收端将传来的数据进行译码(解码)。
对于双工信道(即可以双向传输信息的信道),每端都需要一个完整的编/译码系统。
试为这样的信息收发站设计一个哈夫曼编/译码系统。
2.一个完整的系统应具有以下功能:1)初始化(Initialzation)。
从数据文件DataFile.dat中读入字符及每个字符的权值,建立哈夫曼树HuffTree;2)编码(EnCoding)。
用已建好的哈夫曼树,对文件ToBeTran.dat中的文本进行编码形成报文,将报文写在文件Code.txt中;3)译码(Decoding)。
利用已建好的哈夫曼树,对文件CodeFile.dat中的代码进行解码形成原文,结果存入文件Textfile.txt中;4)输出(Output): 输出DataFile.dat中出现的字符以及各字符出现的频度(或概率);输出ToBeTran.dat及其报文Code.txt;输出CodeFile.dat及其原文Textfile.txt;要求:所设计的系统应能在程序执行的过程中,根据实际情况(不同的输入)建立DataFile.dat、ToBeTran.dat和CodeFile.dat三个文件,以保证系统的通用性。
四、实验步骤(包括主要步骤、代码分析等)1)编写C语言程序#include<string.h>#include<malloc.h>#include<stdio.h>#include<iostream.h>#include<math.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef struct{char data;int weight;int parent,lchild,rchild;}HTNode,*HuffmanTree;typedef char **HuffmanCode;void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,char *d,int *w,int n) //构造哈弗曼函数HT,构造编码HC{void select(HuffmanTree HT,int n,int &s1,int &s2);int m,c,f,j;HuffmanTree p;int i,s1,s2,start;char *cd;m=2*n-1; //m为结点数,n为叶子数HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));p=HT;p++;for(i=1;i<=n;i++,p++) //将叶子的值输入HT中{p->data=d[i]; //={*d,*w,0,0,0};p->weight=w[i];p->parent=0;p->lchild=0;p->rchild=0;}for (i=n+1;i<=m;i++,p++) //={'#',0,0,0,0} {p->data='#';p->weight=0;p->parent=0;p->lchild=0;p->rchild=0;}s1=1;s2=2;for(i=n+1;i<=m;i++) //构建哈夫曼树{select(HT,i-1,s1,s2);HT[i].lchild=s1;HT[i].rchild=s2;HT[i].weight=HT[s1].weight+HT[s2].weight;HT[s1].parent=i;HT[s2].parent=i;}HC=(HuffmanCode)malloc((n+1)*sizeof(HuffmanTree)); //开辟空间,编码cd=(char *)malloc(n*sizeof(char));cd[n-1]='\0';for (i=1;i<=n;++i){start=n-1;for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent){if(HT[f].lchild==c)cd[--start]='0';elsecd[--start]='1';}HC[i]=(char*)malloc((n-start)*sizeof(char));strcpy(HC[i],&cd[start]);printf("%c的编码是:",HT[i]);puts(HC[i]);}free(cd);}void select(HuffmanTree HT,int n,int &s1,int &s2) //求最小两数{int i,t;s1=1;s2=2;while(HT[s1].parent!=0)s1++;while((HT[s2].parent!=0)||(s1==s2))s2++;/*for(i=1;i<=n;i++){if(HT[s1].weight>HT[i].weight&&HT[i].parent==0&&s2!=i)s1=i;}if(HT[s1].weight>HT[s2].weight){t=s1;s1=s2;s2=t;}for(i=1;i<=n;i++){if(s1!=i){if(HT[s2].weight>HT[i].weight&&HT[i].parent==0)s2=i;}}*/for(i=1;i<=n;i++){if(s1!=i&&i!=s2){if(HT[i].weight<HT[s1].weight&&HT[i].parent==0&&i!=s2) {if(HT[s1].weight<HT[s2].weight) s2=s1;s1=i;}elseif(HT[i].weight<HT[s2].weight&&HT[i].parent==0&&s1!=i) s2=i;}}}void translation(HuffmanTree HT,int num){char str[20];int i,t=num;printf("请输入由0或1组成的编码:");cin>>str;//t=HT; //t为树的指向各节点的指针for(i=0;i<(strlen(str));i++){if(str[i]=='0')t=HT[t].lchild;elseif(str[i]=='1')t=HT[t].rchild;else{printf("编码输入错误");break;}if(!(HT[t].lchild&&HT[t].rchild)){printf("%c",HT[t].data);t=num;}}printf("\n");}void main(){void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,char d[],int w[],int n);void translation(HuffmanTree HT,int num);HuffmanTree HT=NULL;HuffmanCode HC=NULL;char data,n,*p,*d;int *w,wei,i,num;printf("please intput character number:");scanf("%d",&n);d=(char*)malloc((n+1)*sizeof(char));w=(int *)malloc((n+1)*sizeof(int));printf("请输入Huffman树中的字符:\n");for(i=1;i<=n;i++){cin>>data;d[i]=data;}printf("请输入%d次位权\n:",n);for (i=1;i<=n;i++){cin>>wei;w[i]=wei;}num=2*n-1;HuffmanCoding(HT,HC,d,w,n);translation(HT,num);}2)程序分析此实验是构造哈夫曼树,求出哈夫曼编码然后输出构造哈夫曼树的算法操作时选出两棵根节点的权值最小的一颗树的左右子树,且置新树的根节点的权值为其左右子树上根节点的权值之和,根据哈夫曼树求出带权路径的算法操作是用递归调用的方法。
数据结构哈夫曼树实验报告

数据结构哈夫曼树实验报告一、实验内容本次实验的主要内容是哈夫曼树的创建和编码解码。
二、实验目的1. 理解并掌握哈夫曼树的创建过程;2. 理解并掌握哈夫曼编码的原理及其实现方法;3. 掌握哈夫曼树的基本操作,如求哈夫曼编码和哈夫曼解码等;4. 学习如何组织程序结构,运用C++语言实现哈夫曼编码和解码。
三、实验原理哈夫曼树的创建:哈夫曼树的创建过程就是一个不断合并权值最小的两个叶节点的过程。
具体步骤如下:1. 将所有节点加入一个无序的优先队列里;2. 不断地选出两个权值最小的节点,并将它们合并成为一个节点,其权值为这两个节点的权值之和;3. 将新的节点插入到队列中,并继续执行步骤2,直到队列中只剩下一棵树,这就是哈夫曼树。
哈夫曼编码:哈夫曼编码是一种无损压缩编码方式,它根据字符出现的频率来构建编码表,并通过编码表将字符转换成二进制位的字符串。
具体实现方法如下:1. 统计每个字符在文本中出现的频率,用一个数组记录下来;2. 根据字符出现的频率创建哈夫曼树;3. 从根节点开始遍历哈夫曼树,给左分支打上0的标记,给右分支打上1的标记。
遍历每个叶节点,将对应的字符及其对应的编码存储在一个映射表中;4. 遍历文本中的每个字符,查找其对应的编码表,并将编码字符串拼接起来,形成一个完整的编码字符串。
哈夫曼解码就是将编码字符串还原为原始文本的过程。
具体实现方法如下:1. 从根节点开始遍历哈夫曼树,按照编码字符串的位数依次访问左右分支。
如果遇到叶节点,就将对应的字符记录下来,并重新回到根节点继续遍历;2. 重复步骤1,直到编码字符串中的所有位数都被遍历完毕。
四、实验步骤1. 定义编码和解码的结构体以及相关变量;3. 遍历哈夫曼树,得到每个字符的哈夫曼编码,并将编码保存到映射表中;4. 将文本中的每个字符用其对应的哈夫曼编码替换掉,并将编码字符串写入到文件中;5. 使用哈夫曼编码重新构造文本,并将结果输出到文件中。
五、实验总结通过本次实验,我掌握了哈夫曼树的创建和哈夫曼编码的实现方法,也学会了如何用C++语言来组织程序结构,实现哈夫曼编码和解码。
哈夫曼树 实验报告

哈夫曼树实验报告哈夫曼树实验报告引言:哈夫曼树是一种经典的数据结构,广泛应用于数据压缩、编码和解码等领域。
本次实验旨在通过构建哈夫曼树,探索其原理和应用。
一、哈夫曼树的定义和构建方法哈夫曼树是一种特殊的二叉树,其叶子节点对应于待编码的字符,而非叶子节点则是字符的编码。
构建哈夫曼树的方法是通过贪心算法,即每次选择权值最小的两个节点合并,直到构建出完整的哈夫曼树。
二、哈夫曼编码的原理和实现哈夫曼编码是一种可变长度编码,即不同字符的编码长度不同。
其原理是通过构建哈夫曼树来确定字符的编码,使得频率较高的字符编码较短,频率较低的字符编码较长。
这样可以有效地减少编码的长度,从而实现数据的压缩。
三、实验过程和结果在本次实验中,我们选择了一段文本作为输入数据,通过统计每个字符的频率,构建了对应的哈夫曼树。
然后,根据哈夫曼树生成了字符的编码表,并将原始数据进行了编码。
最后,我们通过对编码后的数据进行解码,验证了哈夫曼编码的正确性。
实验结果显示,通过哈夫曼编码后,原始数据的长度明显减少,达到了较好的压缩效果。
同时,解码后的数据与原始数据完全一致,证明了哈夫曼编码的可靠性和正确性。
四、哈夫曼树的应用哈夫曼树在实际应用中有着广泛的用途。
其中,最典型的应用之一是数据压缩。
通过使用哈夫曼编码,可以将大量的数据压缩为较小的存储空间,从而节省了存储资源。
此外,哈夫曼树还被广泛应用于网络传输、图像处理等领域,提高了数据传输的效率和图像的质量。
五、对哈夫曼树的思考哈夫曼树作为一种经典的数据结构,其优势在于有效地减少了数据的冗余和存储空间的占用。
然而,随着技术的不断发展,现代的数据压缩算法已经不再局限于哈夫曼编码,而是采用了更为复杂和高效的算法。
因此,我们需要在实际应用中综合考虑各种因素,选择合适的压缩算法。
六、总结通过本次实验,我们深入了解了哈夫曼树的原理和应用。
哈夫曼编码作为一种重要的数据压缩算法,具有广泛的应用前景。
在实际应用中,我们需要根据具体情况选择合适的压缩算法,以达到最佳的压缩效果和性能。
哈夫曼树实验报告

哈夫曼树实验报告一、需求分析(1)输入输出形式输入数组的组数n: 整形变量组数(回车)请依次输入n组权值与字符, 中间用空格隔开。
如“2 a”:按右提示格式输入(回车)请输入待编译文本: 随机输入字符(回车)输出: 编译出的代码请输入待编译代码: 随机输入一串代码(回车)(2)输出: 编译出的代码(3)程序功能1. 用C语言实现二叉树的说明2. 输入n个权值, 并生成n个二叉树3. 对n个二叉树逐步生成Huffman树4. 对Huffman树的每个叶子结点生成编码5.用哈夫曼树编码。
6.解码哈夫曼编码。
(4)测试用例设计Example1: 输入325 a15 b60 cabbacc010*******输出010*******abbaccExample2: 输入510 a20 b30 c20 d10 eababcde10000100001101101输出10000100001101101ababcde二、概要设计1.根据给定的n个权值(w1, w2, …, wn)构成n棵二叉树的集合F={T1, T2, …, Tn}, 其中每棵二叉树Ti中只有一个带树为Ti的根结点在F中选取两棵根结点的权值最小的树作为左右子树构造一棵新的二叉树, 且置其根结点的权值为其左右子树权值之和3.在F中删除这两棵树, 同时将新得到的二叉树加入F中4.重复2, 3, 直到F只含一棵树为止三、 5.将给定的字符串通过程序编码成哈夫曼编码, 并打印结果在屏幕上。
四、 6.翻译给定的哈夫曼编码变成可读字符串, 并将结果打印在屏幕上。
五、详细设计四、调试分析(1)编译代码、运行代码所遇到的问题及其解决办法问题1: 编译代码过程中有遇到循环体的循环次数不对, 导致二叉树生成得不对解决办法:通过小数字的演算, 检验循环, 再进行更改(2)算法的时空分析(3)心得体会五、用户使用说明如上图所示, 依次输入组数、权值及全值所对应字符。
再根据用户自身需求输入需编译的文本及代码。
哈夫曼树实验报告 (2)

三、实验要求
设计思路: 数据结构: #define n 100ﻩﻩ//叶子结点数 #define m 2*n-1// Huffman 树中结点总数 typedef struct {
ﻩint weight; //权值 ﻩint lchild , rchild , parent; //左右孩子及双亲指针
scanf ("%d",w+i);
HuffmanCoding(HT,HC,w,n);
for(i=1;i<=n;i++){
printf("对应得编码为:");
puts(HC[i]);}
}
}
//****从叶子到根逆向求每个字符得赫夫曼编码****
HC=(HuffmanCode)malloc((n+1)*sizeof(char*));//分配n个字符编码得头指针向量
cd=(char*)malloc(n*sizeof(char));
//分配求编码得工作区间
cd[n-1]='\0';
//编码结束符
else cd[--start]='1';
HC[i]=(char *)malloc((n-start)*sizeof(char)); //为第i个字符编码分配空间
strcpy(HC[i],&cd[start]);
//从 cd 复制编码(串)到 HC
}
free(cd);
//释放空间
}
void main()
for(i=1;i<=n;++i)
//逐个字符求赫夫曼树编码
{ int start;
start=n-1;
//编码结束符位置
哈夫曼树实验报告

哈夫曼树实验报告一、实验目的1.理解哈夫曼树的概念和实现原理;2.掌握使用哈夫曼树进行编码和解码的方法;3.熟悉哈夫曼树在数据压缩中的应用。
二、实验原理哈夫曼树是一种用于数据压缩的树形结构,通过将出现频率较高的数据项用较短的编码表示,从而达到压缩数据的目的。
哈夫曼树的构建过程如下:1.统计字符出现的频率,并按照频率从小到大排序;2.将频率最低的两个字符合并为一个节点,节点的频率为两个字符的频率之和;3.将新节点插入频率表,并将频率表重新排序;4.重复步骤2和3,直到频率表中只剩下一个节点,该节点即为哈夫曼树的根节点。
三、实验步骤1.统计输入的字符序列中每个字符出现的频率;2.根据频率构建哈夫曼树;3.根据哈夫曼树生成字符的编码表;4.将输入的字符序列编码为哈夫曼编码;5.根据哈夫曼树和编码表,解码得到原始字符序列。
四、实验结果以字符序列"abacabad"为例进行实验:1.统计字符频率的结果为:a-4次,b-2次,c-1次,d-1次;```a-4/\b-2c-1/\d-1空节点```3.根据哈夫曼树生成的编码表为:a-0,b-10,c-110,d-111;5. 根据哈夫曼树和编码表进行解码得到原始字符序列:"abacabad"。
五、实验总结通过本次实验,我深入了解了哈夫曼树的原理和实现方法,掌握了使用哈夫曼树进行字符编码和解码的过程。
哈夫曼树在数据压缩中的应用非常广泛,能够有效地减小数据的存储空间,提高数据传输效率。
在实际应用中,我们可以根据不同字符出现的频率构建不同的哈夫曼树,从而实现更高效的数据压缩和解压缩算法。
哈夫曼树实验实验报告(3篇)

第1篇一、实验目的1. 理解哈夫曼树的基本概念和构造方法。
2. 掌握哈夫曼编码和译码的原理及实现过程。
3. 熟练运用哈夫曼树解决实际问题,提高数据压缩效率。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验内容1. 构造哈夫曼树2. 哈夫曼编码3. 哈夫曼译码四、实验步骤1. 数据准备(1)创建一个包含字符及其权值的数组,例如:`{'a', 5, 'b', 9, 'c', 12, 'd', 13, 'e', 16, 'f', 45}`。
(2)根据数组内容,使用C++编写程序,实现以下功能:- 将数组元素插入到最小堆中。
- 构建哈夫曼树。
2. 哈夫曼编码(1)遍历哈夫曼树,记录每个字符的编码。
(2)根据编码规则,将字符和编码存储在映射表中。
(3)将映射表输出到文件中。
3. 哈夫曼译码(1)从文件中读取编码序列。
(2)根据哈夫曼树,逐个解码字符。
(3)将解码后的字符输出到文件中。
五、实验结果1. 哈夫曼树```45/ \16 29/ \ / \13 3 12 4/ \ / / \d c b a f```2. 哈夫曼编码```a: 0b: 100c: 101d: 110e: 111f: 1```3. 编码前后的数据```原始数据:abcdef编码后数据:0100110110111011```六、实验分析1. 哈夫曼树通过构建哈夫曼树,可以将权值较小的字符分配较短的编码,权值较大的字符分配较长的编码,从而提高数据压缩效率。
2. 哈夫曼编码哈夫曼编码是一种前缀编码,可以保证解码过程不会产生歧义。
3. 哈夫曼译码通过哈夫曼树,可以快速地将编码序列解码为原始数据。
七、实验总结1. 通过本次实验,掌握了哈夫曼树的基本概念、构造方法、编码和译码原理。
哈弗曼树实验报告(3篇)

一、实验目的1. 理解并掌握哈弗曼树的构建原理。
2. 学会使用哈弗曼树进行数据编码和解码。
3. 了解哈弗曼编码在数据压缩中的应用。
二、实验原理哈弗曼树(Huffman Tree)是一种带权路径长度最短的二叉树,用于数据压缩。
其基本原理是:将待编码的字符集合按照出现频率从高到低排序,构造一棵二叉树,使得叶子节点代表字符,内部节点代表编码,权值代表字符出现的频率。
通过这棵树,可以生成每个字符的编码,使得编码的平均长度最小。
三、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019四、实验步骤1. 构建哈弗曼树(1)创建一个结构体`HuffmanNode`,包含字符、权值、左子树和右子树指针。
```cppstruct HuffmanNode {char data;int weight;HuffmanNode left;HuffmanNode right;};(2)定义一个函数`HuffmanTree()`,用于创建哈弗曼树。
```cppHuffmanNode HuffmanTree(std::vector<char>& chars, std::vector<int>& weights) {// 创建初始二叉树std::vector<HuffmanNode> trees;for (int i = 0; i < chars.size(); ++i) {trees.push_back(new HuffmanNode{chars[i], weights[i], nullptr, nullptr});}// 构建哈弗曼树while (trees.size() > 1) {// 选择两个权值最小的节点auto it1 = std::min_element(trees.begin(), trees.end(),[](HuffmanNode a, HuffmanNode b) {return a->weight < b->weight;});auto it2 = std::next(it1);HuffmanNode parent = new HuffmanNode{0, it1->weight + it2->weight, it1, it2};// 删除两个子节点trees.erase(it1);trees.erase(it2);// 将父节点添加到二叉树集合中trees.push_back(parent);}// 返回哈弗曼树根节点return trees[0];}```2. 生成哈弗曼编码(1)定义一个函数`GenerateCodes()`,用于生成哈弗曼编码。
数据结构实验报告(哈夫曼树)

数据结构实验报告实验题目:Huffman编码与解码姓名:学号:院系:实验名称:Huffman编码与解码实验问题描述:本实验需要以菜单形式完成以下功能:1.输入电文串2.统计电文串中各个字符及其出现的次数3.构造哈弗曼树4.进行哈弗曼编码5.将电文翻译成比特流并打印出来6.将比特流还原成电文数据结构的描述:逻辑结构:本实验可用二叉树实现,其逻辑结构为一对二的形式,即一个结点对应两个结点。
在实验过程中我们也应用到了栈的概念。
存储结构:使用结构体来对数据进行存储:typedef struct{int weight;int parent,lc,rc;}HTNode,*HuffmanTree;typedef struct LNode{char *elem;int stacksize;int top;}SqStack;在main函数里面定义一个哈弗曼树并实现上述各种功能。
程序结构的描述:本次实验一共构造了10个函数:1.void HuffTree(HuffmanTree &HT,int n[],int mun);此函数根据给定的mun个权值构建哈弗曼树,n[]用于存放num个权值。
2.void Select(HuffmanTree &HT,int n,int i,int &s1,int &s2);此函数用于在HT[1,i-1]中选择parent为0且weight为最小的两个结点,其下标分别为s1,s2.3.void HuffmanCoding(HuffmanTree HT,char **&HC,int n);此函数从哈弗曼树HT上求得n 个叶子结点的哈弗曼编码并存入数组HC中。
4.void Coding(HuffmanTree HT,char **HC,int root,SqStack &S);此函数用于哈弗曼编码,先序遍历哈弗曼树HT,求得每个叶子结点的编码字符串,存入数组HC,S为一个顺序栈,用来记录遍历路径,root是哈弗曼数组HT中根结点的位置下标。
哈夫曼树实验报告(上传)

201*级数据结构实验报告哈夫曼树的建立姓名:***学号:***********班级:指导老师:***日期:201*.12.25一、实验题目及要求:实验题目:哈夫曼编码器设计实验要求:哈夫曼(Huffman)树与哈夫曼码1.输入一个文本,统计各字符出现的频度,输出结果;2.使用二叉链表或三叉链表作存储结构,构造哈夫曼(Huffman)树; 3.确定和输出各字符的哈夫曼码;4.输入一个由0和1组成的代码序列,翻译并输出与之对应的文本;操作提示:一个完整的系统应具有以下功能:(1)初始化: 从终端读入一段英文字符,统计每个字符出现的频率,建立赫夫曼树,并将该树存入某文件;(2)编码: 利用建好的赫夫曼树对各字符进行编码,用列表的形式显示在屏幕上,并将编码结果存入另一文件中;(3)解码: 利用保存的赫夫曼编码,对任意输入的0,1序列能正确解码。
二、实验分析及内容1、 存储结构a. 哈夫曼树的存储结构该程序使用一个静态三叉链表来存储哈夫曼树:weight LChild RChild Parent 2 -1 -1 4 3 -1 -1 4 6 -1 -1 5 9 -1 -1 6 5 1 1 5 11 2 2 6 2055-1b. 哈夫曼编码表的存储结构把每个字符data 及对应的编码code 用一个结点存储,将所有的结点存储在数组中:data Code Z 100 C 101 B 11 Ac. 录入字符串以及存储字符的数组a[]、b[]的获取:先将录入的字符串存在一个字符数组S[]中,然后遍历数组S[],先建立一个空的循环链表,然后再遍历数组S 的同时往链表里插入新的结点或者修改相应结点中的域值:0 1 2 3 4 5 60 1 2 3Data Weight Nextrrear2. 关键算法分析a.初始化哈夫曼树:用数组a[]初始化哈夫曼树:从0到n-1循环,分别对树中结点赋值:HTree[i].weight=a[i];HTree[i].lchild=-1;HTree[i].rchild=-1;HTree[i].parent=-1;b.创建哈夫曼树:(1)、从1——i中选择两个最小的结点:SelectMin(x,y,0,i);(2)、将选中的两个结点插入到树中:HTree[x].parent=HTree[y].parent=ii;HTree[ii].weight=HTree[x].weight+HTree[y].weight;HTree[ii].lchild=x;HTree[ii].rchild=y;HTree[ii].parent=-1;d.创建编码表:(1)、自下而上从叶子节点找到根节点,左孩子标识为‘0’,右孩子标识为‘1’,将‘0’、‘1’储存在编码表的code[]中;(2)、将code[]中的‘0’、‘1’进行倒序;e.编码:根据编码表,进行编码:for(int i=0;i<n;i++){ if(*s==HCodeTable[i].data){cout<<HCodeTable[i].code;s++;}}f.译码:输入一串‘0’、‘1’代码,根据编码表进行译码:(1)、如果是‘0’,则转到当前结点的左孩子:if(*s=='0') parent=HTree[parent].lchild;(2)、如果是‘1’,则转到当前结点的右孩子:else parent=HTree[parent].rchild;5、源程序:#include "stdio.h"typedef struct{float weight;int parent,lchild,rchild;}huftree;typedef struct{int bit[100];int length;}hufcode;huftree tree[100];//哈夫曼树hufcode code[100];//编码int num,m;//个数,编码最大长度void HufBuild(){int i,j,p1,p2;float s1,s2;printf("How: ");scanf("%d",&num);m=2*num-1;printf("请输入各个编码频率: ");for(i=0;i<num;i++){scanf("%f",&tree[i].weight);tree[i+num].parent=tree[i].parent=0;tree[i+num].lchild=tree[i].lchild=0;tree[i+num].rchild=tree[i].rchild=0;}for(i=num;i<m;i++){s1=s2=1; p1=p2=0;for(j=0;j<i;j++)if(tree[j].parent==0)if(tree[j].weight<s1){s2=s1; s1=tree[j].weight;p2=p1; p1=j;}else if(tree[j].weight<s2){s2=tree[j].weight;p2=j;}tree[p1].parent=tree[p2].parent=i;tree[i].weight=tree[p1].weight+tree[p2].weight;tree[i].lchild=p1; tree[i].rchild=p2;}}void CodePrint(){int i,j,p,k;printf("各个编码如下: \n");for(i=0;i<num;i++){printf("%6.2f",tree[i].weight);p=tree[i].parent;j=i;code[i].length=num-1;while(p!=0){if(tree[p].lchild==j) code[i].bit[code[i].length]=1;else code[i].bit[code[i].length]=0;code[i].length--;j=p;p=tree[p].parent;}printf(" ");for(k=code[i].length+1;k<num;k++)printf("%d",code[i].bit[k]);printf("\n");}}void main(){printf("输入一个要进行哈夫曼编码的字符串:"); gets();printf("如下是编码表:");HufBuild();pringtf("请输入一串0和1的代码");CodePrint();}3、运行结果三、实验小结1、虽然最终顺利的编完了程序,但是总的来说哈夫曼树还是很不容易的。
数据结构实验报告 哈夫曼树的实现

数据结构实验报告实验二Huffman树1、实验目的通过选择下面两个题目之一进行实现,掌握如下内容:➢掌握二叉树基本操作的实现方法➢了解哈夫曼树的思想和相关概念➢学习使用二叉树解决实际问题的能力2、实验内容利用二叉树结构实现哈夫曼编/解码器。
基本要求:1、初始化(Init):能够对输入的任意长度的字符串s进行统计,统计每个字符的频度,并建立赫夫曼树2、建立编码表(CreateTable):利用已经建好的哈夫曼树进行编码,并将每个字符的编码输出。
3、编码(Encoding):根据编码表对输入的字符串进行编码,并将编码后的字符串输出。
4、译码(Decoding):利用已经建好的哈夫曼树对编码后的字符串进行译码,并输出译码结果。
5、打印(Print):以直观的方式打印哈夫曼树(选作)6、计算输入的字符串编码前和编码后的长度,并进行分析,讨论哈夫曼编码的压缩效果。
代码要求:1、必须要有异常处理,比如删除空链表时需要抛出异常;2、保持良好的编程的风格:➢代码段与段之间要有空行和缩近➢标识符名称应该与其代表的意义一致➢函数名之前应该添加注释说明该函数的功能➢关键代码应添加注释说明其功能3、递归程序注意调用的过程,防止栈溢出4、代码中需要标注每一个函数的时间复杂度三、算法思路与主要代码1.设计存储结构1.1 哈夫曼树的结点结构struct HNode //哈夫曼树的结点结构{int weight;//结点权值int parent;//双亲指针int LChild;//左孩子指针int RChild ;//右孩子指针};1.2 编码表结点结构struct HCode //编码表结点结构{char data;char code[100];};1.3哈夫曼树类结构class Huffman //哈夫曼树类结构{private:HNode* HTree;HCode* HCodeTable;char str[1024];char leaf[256];int a[256];void code(int i,string newcode);public:int n;void init();void CreateHtree();void SelectMin(int &x, int &y, int s,int e);void CreateCodeTable();void Encode(char *d);void Decode(char *s, char *d);void print(int i,int m);~Huffman(); //析构函数};2.统计字符串中的字频扫描原始数据,用整型数组变量nNum来记录每一个字符出现的次数当字符没有出现时,对应的nNum[ch]的值为0,可以把读取的字符ch的ASCII码当成,当ch出现时,nNum[ch]自动加一从而统计输入字符串中各个字符数量,获得各个字符出现频率。
哈夫曼树实验报告

哈夫曼树实验报告计算机科学与技术学院数据结构实验报告班级2014级计算机1班学号20144138021 姓名张建华成绩实验项目简单哈夫曼编/译码得设计与实现实验日期2016、1、5一、实验目得本实验得目得就是进一步理解哈夫曼树得逻辑结构与存储结构,进一步提高使用理论知识指导解决实际问题得能力。
二、实验问题描述利用哈夫曼编码进行通信可以大大提高信道利用率,缩短信息传输时间,降低传输成本。
但就是,这要求在发送端通过一个编码系统对待传数据预先编码,在接收端将传来得数据进行译码,此实验即设计这样得一个简单编/码系统。
系统应该具有如下得几个功能:1、接收原始数据。
从终端读入字符集大小n,以及n个字符与n个权值,建立哈夫曼树,并将它存于文件hfm tree、dat中。
2、编码。
利用已建好得哈夫曼树(如不在内存,则从文件hfmtree、dat中读入),对文件中得正文进行编码,然后将结果存入文件code中。
3、译码。
利用已建好得哈夫曼树将文件code中得代码进行译码,结果存入文件text中。
4、打印编码规则。
即字符与编码得一一对应关系。
5、打印哈夫曼树,将已在内存中得哈夫曼树以直观得方式显示在终端上。
三、实验步骤1、实验问题分析1、构造哈夫曼树时使用静态链表作为哈夫曼树得存储。
在构造哈夫曼树时,设计一个结构体数组HuffNode保存哈夫曼树中各结点得信息,根据二叉树得性质可知,具有n个叶子结点得哈夫曼树共有2n-1个结点,所以数组HuffNode得大小设置为2n -1,描述结点得数据类型为:Typedef strcut{Int weight;/*结点权值*/Int parent;Int lchild;Int rchild;}HNodeType;2、求哈夫曼编码时使用一维结构数组HuffCode作为哈夫曼编码信息得存储。
求哈夫曼编码,实质上就就是在已建立得哈夫曼树中,从叶子结点开始,沿结点得双亲链域回退到根结点,没回退一步,就走过了哈夫曼树得一个分支,从而得到一位哈夫曼码值,由于一个字符得哈夫曼编码就是从根结点到相应叶子结点所经过得路径上各分支所组成得0、1序列,因此先得到得分支代码为所求编码得低位码,后得到得分支代码位所求编码得高位码,所以设计如下数据类型:#define MAXBIT 10Typedef struct{Int bit[MAXBIT];Intstart;}HCodeType;3、文件hfmtree、dat、code与text。
数据结构实验哈夫曼树及哈夫曼编码c语言

数据结构实验报告:哈夫曼树及哈夫曼编码一、实验目的1. 理解哈夫曼树及哈夫曼编码的概念和原理;2. 掌握C语言中哈夫曼树及哈夫曼编码的实现方法;3. 分析和讨论哈夫曼编码在实际应用中的优势和不足。
二、实验内容和步骤1. 哈夫曼树的构建1.1 通过C语言实现哈夫曼树的构建算法;1.2 输入一组权值,按哈夫曼树构建规则生成哈夫曼树;1.3 输出生成的哈夫曼树结构,并进行可视化展示。
2. 哈夫曼编码的实现2.1 设计哈夫曼编码的实现算法;2.2 对指定字符集进行编码,生成哈夫曼编码表;2.3 对给定字符串进行哈夫曼编码,并输出编码结果。
三、实验过程及结果1. 哈夫曼树的构建在C语言中,通过定义结构体和递归算法实现了哈夫曼树的构建。
根据输入的权值,依次选择权值最小的两个节点构建新的父节点,直至构建完成整棵哈夫曼树。
通过调试和可视化展示,确认了程序正确实现了哈夫曼树的构建。
2. 哈夫曼编码的实现经过分析和设计,利用哈夫曼树的特点实现了哈夫曼编码的算法。
根据生成的哈夫曼树,递归地生成字符对应的哈夫曼编码,并输出编码结果。
对指定的字符串进行了编码测试,验证了哈夫曼编码的正确性和有效性。
四、实验结果分析1. 哈夫曼编码在数据传输和存储中具有较高的压缩效率和可靠性,能够有效减少数据传输量和存储空间;2. 哈夫曼树及哈夫曼编码在通信领域、数据压缩和加密等方面有着广泛的应用和重要意义;3. 在实际应用中,哈夫曼编码的构建和解码算法需要较大的时间和空间复杂度,对于大规模数据的处理存在一定的局限性。
五、实验总结通过本次实验,深入理解了哈夫曼树及哈夫曼编码的理论知识,并掌握了C语言中实现哈夫曼树及哈夫曼编码的方法。
对哈夫曼编码在实际应用中的优势和局限性有了更深入的认识,这对今后的学习和工作有着积极的意义。
六、参考文献1. 《数据结构(C语言版)》,严蔚敏赵现军著,清华大学出版社,2012年;2. 《算法导论》,Thomas H. Cormen 等著,机械工业出版社,2006年。
数据结构哈夫曼树实验报告

数据结构哈夫曼树实验报告一、实验目的本次实验的主要目的是深入理解和掌握哈夫曼树的数据结构及其相关算法,并通过实际编程实现来提高对数据结构的应用能力和编程技能。
二、实验环境本次实验使用的编程环境为具体编程语言名称,操作系统为具体操作系统名称。
三、实验原理哈夫曼树,又称最优二叉树,是一种带权路径长度最短的二叉树。
其基本原理是通过构建一棵二叉树,使得权值较大的节点距离根节点较近,权值较小的节点距离根节点较远,从而达到带权路径长度最小的目的。
在构建哈夫曼树的过程中,首先需要将所有的节点按照权值从小到大进行排序。
然后,选取权值最小的两个节点作为左右子树,构建一个新的父节点,该父节点的权值为左右子节点权值之和。
重复这个过程,直到所有的节点都被构建到哈夫曼树中。
哈夫曼编码是基于哈夫曼树的一种编码方式。
对于每个叶子节点,从根节点到该叶子节点的路径上,向左的分支编码为 0,向右的分支编码为 1,这样就可以得到每个叶子节点的哈夫曼编码。
四、实验步骤1、定义节点结构体```ctypedef struct HuffmanNode {char data;int weight;struct HuffmanNode left;struct HuffmanNode right;} HuffmanNode;```2、实现节点排序函数```cvoid sortNodes(HuffmanNode nodes, int n) {for (int i = 0; i < n 1; i++){for (int j = 0; j < n i 1; j++){if (nodesj>weight > nodesj + 1>weight) {HuffmanNode temp = nodesj;nodesj = nodesj + 1;nodesj + 1 = temp;}}}}```3、构建哈夫曼树```cHuffmanNode buildHuffmanTree(HuffmanNode nodes, int n) {while (n > 1) {sortNodes(nodes, n);HuffmanNode left = nodes0;HuffmanNode right = nodes1;HuffmanNode parent =(HuffmanNode )malloc(sizeof(HuffmanNode));parent>data ='\0';parent>weight = left>weight + right>weight;parent>left = left;parent>right = right;nodes0 = parent;nodes1 = nodesn 1;n;}return nodes0;}```4、生成哈夫曼编码```cvoid generateHuffmanCodes(HuffmanNode root, int codes, int index) {if (root>left) {codesindex = 0;generateHuffmanCodes(root>left, codes, index + 1);}if (root>right) {codesindex = 1;generateHuffmanCodes(root>right, codes, index + 1);}if (!root>left &&!root>right) {printf("%c: ", root>data);for (int i = 0; i < index; i++){printf("%d", codesi);}printf("\n");}}```5、主函数```cint main(){HuffmanNode nodes5 ={(HuffmanNode )malloc(sizeof(HuffmanNode)),(HuffmanNode )malloc(sizeof(HuffmanNode)),(HuffmanNode )malloc(sizeof(HuffmanNode)),(HuffmanNode )malloc(sizeof(HuffmanNode)),(HuffmanNode )malloc(sizeof(HuffmanNode))};nodes0>data ='A';nodes0>weight = 5;nodes1>data ='B';nodes1>weight = 9;nodes2>data ='C';nodes2>weight = 12;nodes3>data ='D';nodes3>weight = 13;nodes4>data ='E';nodes4>weight = 16;HuffmanNode root = buildHuffmanTree(nodes, 5);int codes100;generateHuffmanCodes(root, codes, 0);return 0;}```五、实验结果与分析通过运行上述程序,得到了每个字符的哈夫曼编码:A: 00B: 01C: 10D: 110E: 111分析实验结果可以发现,权值较小的字符A 和B 对应的编码较短,而权值较大的字符D 和E 对应的编码较长。
树和哈夫曼树实验报告

哈夫曼树实验报告2011.4.22实验题目: Huffman编码和译码。
实验目的:1、练习树和哈夫曼树的有关操作, 和各个算法程序。
2.理解哈夫曼树的编码和译码实验内容:抽象数据类型:ADT Huffmantree{数据对象: D={带有各自实数W(D)的数据元素}数据关系: (1) D=NULL 则huffman tree 不存在//判断huffman树是否存在(2) D≠NULL R={H}.H为如下二元关系://如果存在, 假设R为其元素名称, H为里边所有元素①D中存在唯一根数据元素root,这个元素无前驱。
//如果只有一个元素, 则为根元素②D-{root} ≠NULL.则存在D-{root} ={D1, Dr}.且D1∧Dr=NULL//如果除了根元素还有别的元素, 那么会有D1和Dr两部分, 并且两者的交集为空, 也就是两者是独立的。
③若D1 ≠NULL , 则D1 中存在唯一元素xr,<root, xr>∈H//如果D1部位空集, 则会有一个元素xr, 且存在Dr上关系Hr ∈H,H= {<root ,x1>,< root, xr>,H1,Hr};④符合①②③的R的组合中, 存在一个组合R’使D中所有结点到root长与其权值W(Di)相乘的和最小, 此时的<D/R>集合称为huffman tree.基本操作:void select(HTNode HT[],int m,int *s1,int *s2)//比较得到权最小的两棵树。
用指针指向所在位置。
*void print1(char *HC[])//将哈弗曼编码逐个打印出来void print2(HTNode HT[])//将哈夫曼树前后的结构打印出来void CreatHuffmanTree(HTNode HT[],lettervalue w[])//建立哈夫曼树void HuffmanTreeCoding(HTNode HT[],char *HC[])//从树根出发, 对哈夫曼树做一次先序遍历, 在遍历过程中利用一个字符//的顺序栈S记下遍历路程, 向左转时0入栈, 向右转时1入栈。
哈夫曼树实验报告

一、实验目的1. 理解哈夫曼树的基本概念和构造方法。
2. 掌握哈夫曼编码的原理和实现过程。
3. 通过实验加深对数据结构中树型结构应用的理解。
二、实验原理哈夫曼树(Huffman Tree)是一种带权重的二叉树,用于实现哈夫曼编码。
其基本思想是:将字符按照在数据集中出现的频率进行排序,然后选取两个最小频率的字符合并成一个新节点,其频率为两个字符频率之和,重复此过程,直到只剩下一个节点,即为哈夫曼树的根节点。
哈夫曼编码是一种基于哈夫曼树的编码方法,其原理是将每个字符映射到一个唯一的二进制序列,序列的长度与字符在数据集中出现的频率成反比。
频率越高,编码的长度越短,从而提高信息传输的效率。
三、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019四、实验步骤1. 初始化(1)从数据文件中读取字符及其频率。
(2)构建一个优先队列(最小堆),将字符和频率存储在队列中。
2. 构建哈夫曼树(1)从优先队列中取出两个频率最小的节点,合并成一个新节点,其频率为两个节点频率之和。
(2)将新节点插入优先队列中。
(3)重复步骤(1)和(2),直到优先队列中只剩下一个节点,即为哈夫曼树的根节点。
3. 哈夫曼编码(1)遍历哈夫曼树,从根节点到叶子节点的路径上,左子树表示0,右子树表示1。
(2)将每个叶子节点的字符和对应的编码存储在哈夫曼编码表中。
4. 编码(1)读取待编码的文本。
(2)根据哈夫曼编码表,将文本中的每个字符映射到对应的编码。
(3)将编码序列写入文件。
5. 译码(1)读取编码文件。
(2)从哈夫曼树的根节点开始,根据编码序列的每一位,判断是左子树还是右子树。
(3)当到达叶子节点时,输出对应的字符。
(4)重复步骤(2)和(3),直到编码序列结束。
五、实验结果与分析1. 实验结果(1)成功构建了哈夫曼树,并生成了哈夫曼编码表。
(2)对给定的文本进行了编码和译码,验证了编码的正确性。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
电子科技大学实验报告课程名称:数据结构与算法学生姓名:陈*浩学号:*************点名序号:***指导教师:钱**实验地点:基础实验大楼实验时间:2015.5.72014-2015-2学期信息与软件工程学院实验报告(二)学生姓名:陈**浩学号:*************指导教师:钱**实验地点:科研教学楼A508实验时间:2015.5.7一、实验室名称:软件实验室二、实验项目名称:数据结构与算法—树三、实验学时:4四、实验原理:霍夫曼编码(Huffman Coding)是一种编码方式,是一种用于无损数据压缩的熵编码(权编码)算法。
1952年,David A. Huffman在麻省理工攻读博士时所发明的。
在计算机数据处理中,霍夫曼编码使用变长编码表对源符号(如文件中的一个字母)进行编码,其中变长编码表是通过一种评估来源符号出现机率的方法得到的,出现机率高的字母使用较短的编码,反之出现机率低的则使用较长的编码,这便使编码之后的字符串的平均长度、期望值降低,从而达到无损压缩数据的目的。
例如,在英文中,e的出现机率最高,而z的出现概率则最低。
当利用霍夫曼编码对一篇英文进行压缩时,e极有可能用一个比特来表示,而z则可能花去25个比特(不是26)。
用普通的表示方法时,每个英文字母均占用一个字节(byte),即8个比特。
二者相比,e使用了一般编码的1/8的长度,z则使用了3倍多。
倘若我们能实现对于英文中各个字母出现概率的较准确的估算,就可以大幅度提高无损压缩的比例。
霍夫曼树又称最优二叉树,是一种带权路径长度最短的二叉树。
所谓树的带权路径长度,就是树中所有的叶结点的权值乘上其到根结点的路径长度(若根结点为0层,叶结点到根结点的路径长度为叶结点的层数)。
树的路径长度是从树根到每一结点的路径长度之和,记为WPL=(W1*L1+W2*L2+W3*L3+...+Wn*Ln),N个权值Wi(i=1,2,...n)构成一棵有N个叶结点的二叉树,相应的叶结点的路径长度为Li(i=1,2,...n)。
可以证明霍夫曼树的WPL是最小的。
五、实验目的:本实验通过编程实现赫夫曼编码算法,使学生掌握赫夫曼树的构造方法,理解树这种数据结构的应用价值,并能熟练运用C语言的指针实现构建赫夫曼二叉树,培养理论联系实际和自主学习的能力,加强对数据结构的原理理解,提高编程水平。
六、实验内容:(1)实现输入的英文字符串输入,并设计算法分别统计不同字符在该字符串中出现的次数,字符要区分大小写;(2)实现赫夫曼树的构建算法;(3)遍历赫夫曼生成每个字符的二进制编码;(4)显示输出每个字母的编码。
七、实验器材(设备、元器件):PC机一台,装有C或C++语言集成开发环境。
八、数据结构与程序:/********************************************************************* *程序名称:哈夫曼树的相关操作*** *程序内容:生成哈夫曼树及其编码表、对字符串进行编码等*** *编写作者:陈家浩*** *完成时间:2015.5.15 ********************************************************************/#include <stdio.h>#include <stdlib.h>#include <string.h>#define MAXSIZE 10000char file_address[100]; //全局通用文件地址typedef struct hnode // 哈夫曼树的节点结构定义{int weight;int lchild, rchild, parent;}THNode, * TpHTree;typedef struct huffman_code // 哈夫曼编码表的元素结构定义{int weight; // 编码对应的权值char * pcode; // 指向编码字符串的指针}THCode, *TpHcodeTab;//*************************************************************// ** **声明函数//*************************************************************TpHcodeTab build_codesheet( TpHTree pht, int leaves_num);// 根据哈夫曼树得到编码表TpHTree create_huffman_tree(int weights[], int n ); // 构造哈夫曼树void select_mintree(TpHTree , int , int *, int *); // 从森林中选择权值最小的两棵子树void destroy_codesheet(TpHcodeTab codesheet, int n); // 销毁哈夫曼编码表int read_file(char file_address[100], char *message); // 从文本文件读入字符串int calc_freq(char text[], int **freq, char **dict, int n); // 统计字符串text中字符出现的频率//*************************************************************// ** **主函数//*************************************************************int main(void){int i, msg_num,choose;char s; //清空缓存int leaves_num = 0;do{TpHTree pht = NULL; //建立树根TpHcodeTab codesheet; //建立编码表char msg[MAXSIZE]; //建立信息数组int *weights = NULL; //建立频率数组char *dict = NULL; //建立字符数组printf(" -------- \n""----------哈夫曼树----------\n"" -------- ");printf("\n读取文件还是手动输入信息?\n"" 1:手动输入信息\n"" 2:读取文件\n"" 请选择:");scanf("%d",&choose);if(choose == 1){printf("请输入信息:\n");scanf("%c",&s); //清理键盘缓存gets(msg);msg_num = strlen(msg);}else{printf("输入文件地址(例如:F:\\\\filename.txt):\n");scanf("%c",&s); //清理键盘缓存gets(file_address); //输入文件地址msg_num = read_file( file_address, msg); //读取文本文件}leaves_num = calc_freq( msg, &weights, &dict, msg_num );//统计文本串中的字符频率,同时得到哈夫曼树的叶节点数pht = create_huffman_tree( weights, leaves_num ); //创建哈夫曼树codesheet = build_codesheet( pht, leaves_num ); //构造哈夫曼编码表printf("\n---字符频率编码表---\n");printf("符号-- 频率-- 编码\n");for(i = 0; i < leaves_num ; i++)printf("%4c -- %-3d -- %-6s\n", dict[i], codesheet[i].weight, codesheet[i].pcode);printf("--------------------\n");destroy_codesheet( codesheet, leaves_num); //销毁哈夫曼编码表if(pht) //释放所有临时空间free(pht);if(dict)free(dict);if(weights)free(weights);printf("\n\t0:结束\n\t1:继续\n""\t请选择:");scanf("%d",&choose);}while(choose);return 0;}//*************************************************************// ** **构造哈夫曼编码表//*************************************************************TpHcodeTab build_codesheet( TpHTree pht, int leaves_num ){int i, cid, pid, cursor, len;TpHcodeTab sheet;char * pch = (char *) malloc( leaves_num + 1 );if( !pch ){printf("申请空间失败!");exit(0);}memset( pch, 0, (leaves_num + 1) ); // 清零新分配的空间sheet = ( TpHcodeTab )malloc( sizeof( THCode ) * leaves_num ); if( !sheet ){printf("申请编码表内存空间失败!");exit(0);}for( i = 0; i < leaves_num; ++i ){sheet[i].weight = pht[i].weight;}for( i = 0; i < leaves_num; ++i ){cursor = leaves_num;cid = i;pid = pht[cid].parent;while( pid!= -1 ) //不为根节点{if (pht[pid].lchild == cid)pch[--cursor] = '0'; // 左分支编码为'0'elsepch[--cursor] = '1'; // 右分支编码为'1'cid = pid;pid = pht[cid].parent;}len = leaves_num - cursor + 1;sheet[i].pcode = ( char * )malloc( len );if( !sheet[i].pcode ){printf("为节点%d的编码申请内存空间失败!", i);exit(0);}memset( sheet[i].pcode, 0, len );strncpy( sheet[i].pcode, &pch[cursor], strlen(&pch[cursor]) ); }free(pch);return sheet;}//************************************************************* // ** **构造哈夫曼树//************************************************************* TpHTree create_huffman_tree( int weights[], int n ){TpHTree pht;int minA, minB; // 用于保存权值最小的两棵子树的序号int i, a = 0;if( n < 1 ){printf("没有叶子节点!\n");return 0;}a = (2 * n) - 1;pht = ( TpHTree ) malloc( sizeof( THNode ) * a );if( !pht ){printf("分配数组空间失败!\n");exit(0);}for( i = 0; i < a; ++i ) // 哈夫曼数组初始化{pht[i].weight = (i < n) ? weights[i] : 0;pht[i].lchild = -1;pht[i].rchild = -1;pht[i].parent = -1;}for( i = n; i < a; ++i ){select_mintree( pht, (i-1), &minA, &minB );pht[minA].parent = i;pht[minB].parent = i;pht[i].lchild = minA;pht[i].rchild = minB;pht[i].weight = pht[minA].weight + pht[minB].weight;}return pht;}//************************************************************* // ** **选出权值最小的两棵子树//************************************************************* void select_mintree(TpHTree pht, int n, int *minA, int *minB){int id, min1 = -1, min2 = -1; //最小值,次小值int maxa = 10000, maxb = 10000;for(id = 0; id <= n; id++){if(pht[id].parent == -1){if( pht[id].weight < maxa ){min2 = min1;min1 = id;maxa = pht[id].weight;}else if(pht[id].weight < maxb ){min2 = id;maxb = pht[id].weight;}}}*minA = min1;*minB = min2;return;}//************************************************************* // ** **销毁哈夫曼编码表//************************************************************* void destroy_codesheet(TpHcodeTab sheet, int n){int i;for(i = 0; i < n; ++i)free(sheet[i].pcode);free(sheet);return;}//************************************************************* // ** **读取文本文件//************************************************************* int read_file(char file_address[100], char *message){int str_len; //字符串长度FILE * pFile = NULL;pFile = fopen( file_address, "r"); //打开文件if(!pFile){printf("打开文件失败!\n");exit(0);}else{printf("打开文件成功!\n");}memset(message, 0, MAXSIZE); //清除缓冲if( fgets( message, MAXSIZE, pFile ) == NULL){printf( "fgets error\n" );exit(0);}else{printf( "成功读取文件,内容如下:\n%s\n", message);}str_len = strlen(message);fclose(pFile);return str_len;}//************************************************************* // ** **统计字符出现的频率//************************************************************* int calc_freq(char text[], int **freq, char **dict, int n)//n为字符串长度{int i, k;int char_num = 0;int * chars; //不同种类的字符char * fre; //字符的出现频率int times[256] = {0};for(i = 0; i < n; ++i) //各个字符出现的频率times[text[i]]++;for(i = 0; i < 256; i++) //不同字符的个数if( times[i] > 0 )char_num++;chars = (int*)malloc(sizeof(int)*char_num);if( !chars ){printf("为频率数组分配空间失败!\n");exit(0);}fre = (char *)malloc(sizeof(char)*char_num);if( !fre ){printf("为字符数组分配空间失败!\n");exit(0);}k = 0;for(i = 0; i < 256; ++i){if( times[i] > 0 ){chars[k] = times[i];fre[k] = (char)i;k++;}}*freq = chars;*dict = fre;return char_num;//不同种类的字符个数}九、程序运行结果:一、手动输入信息二、从文件读取信息十、实验结论:本实验通过编程实现赫夫曼编码算法,在实验中掌握了赫夫曼树的构造方法,理解了树这种数据结构的应用价值,并且已经能够熟练运用指针实现构建赫夫曼二叉树,理论联系实际和自主学习的能力得到了培养,对数据结构的原理理解更加深刻,也提高了编程水平。