实验三哈夫曼树实验报告
数据结构(C语言版)实验报告(哈夫曼树)
《数据结构与算法》实验报告一、需求分析1.问题描述：利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。
但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码(复原)。
对于双工通道（及可以双向传输信息的通道），每端都需要一个完整的编/译码系统。
试为这样的信息收发站写一个哈夫曼的编/译码系统。
2.基本要求一个完整的系统应具有以下功能：（1）I：初始化（Initialization）。
从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmTree中。
（2）E：编码（Encoding）。
利用已建好的哈夫曼树（如不在内存，则从文件hfmTree中读入），对文件ToBeTran中的正文进行编码，然后将结果存入文件CodeFile中。
（3）D：译码（Decoding）。
利用已建好的哈夫曼树将文件CodeFile中的代码进行译码，结果存入文件TextFile中。
（4）P：印代码文件（Print）。
将文件CodeFile以紧凑格式显示在终端上，每行50个代码。
同时将此字符形式的编码文件写入文件CodePrin中。
（5）T：印哈夫曼树（Tree printing）。
将已在内存中的哈夫曼树以直观的方式（树或凹入表形式）显示出，同时将此字符形式的哈夫曼树写入文件TreePrint中。
3.测试数据（1）利用教科书例6-2中的数据调试程序。
（2）用下表给出的字符集和频度的实际统计数据建立哈夫曼树，并实现以下报文的编码和译码：“THIS PROGRAM IS MY FAVORITE”。
4,实现提示（1）编码结果以文本方式存储在文件CodeFile中。
（2）用户界面可以设计为“菜单”方式：显示上述功能符号，再加上“Q”表示退出运行Quit。
请用户键入一个选择功能符。
此功能执行完毕后再显示此菜单，直至某次用户选择了“Q”为止。
（3）在程序的一次执行过程中，第一次执行I、D或C命令之后，哈夫曼树已经在内存了，不必再读入。
哈夫曼树实验报告
数据结构实验报告实验名称：实验三哈夫曼树学生姓名：班级：班内序号：学号：日期：程序分析：2.1 存储结构：二叉树2.2 程序流程：template <class T>class BiTree{public:BiTree(); //构造函数，其前序序列由键盘输入 ~BiTree(void); //析构函数BiNode<T>* Getroot(); //获得指向根结点的指针protected:BiNode<T> *root; //指向根结点的头指针};//声明类BiTree及定义结构BiNodeData：二叉树是由一个根结点和两棵互不相交的左右子树构成二叉树中的结点具有相同数据类型及层次关系哈夫曼树类的数据域，继承节点类型为int的二叉树class HuffmanTree:public BiTree<int>data:HCode* HCodeTable;//编码表int tSize; //编码表中的总字符数二叉树的节点结构template <class T>struct BiNode //二叉树的结点结构{T data; //记录数据T lchild; //左孩子T rchild; //右孩子T parent; //双亲};编码表的节点结构struct HCode{char data; //编码表中的字符char code[100]; //该字符对应的编码};待编码字符串由键盘输入，输入时用链表存储，链表节点为struct Node{char character; //输入的字符unsigned int count;//该字符的权值bool used; //建立树的时候该字符是否使用过Node* next; //保存下一个节点的地址};示意图：2.3 关键算法分析：1.初始化函数（void HuffmanTree::Init(string Input)）算法伪代码：1.初始化链表的头结点2.获得输入字符串的第一个字符，并将其插入到链表尾部,n=1(n记录的是链表中字符的个数)3.从字符串第2个字符开始，逐个取出字符串中的字符3.1 将当前取出的字符与链表中已经存在的字符逐个比较，如果当前取出的字符与链表中已经存在的某个字符相同，则链表中该字符的权值加1。
数据结构与算法实验报告_3霍夫曼树
实验四数据结构与程序设计专题实验报告赫夫曼树学院:物理与电子学院班级:电信1105班姓名:刘岩学号:1404110729实验报告一、实验任务实验题目：数据结构与程序设计专题实验二、实验内容实验三：树的基本操作及基于霍夫曼树的编码/译码（一）实验目的：掌握结构体、指针及二叉树的生成、遍历等操作掌握霍夫曼编码/译码的原理。
（二）基本要求：熟练掌握树的操作。
（三）内容提要：给定一段字符，构建霍夫曼树；根据该树求每个字符的编码，并对该段字符串进行编码；将得到的编码进行译码；基于该霍夫曼树，通过遍历算法来输出该树中的叶子节点。
注：在实现时要求霍夫曼树的左右孩子的大小关系（左孩子节点值小于右孩子节点），在遍历的时候也可以为递归与非递归办法寻找叶子节点。
三、要点分析题目中涉及的主要知识点：1、本程序参考霍夫曼算法（由给定的权值构造赫夫曼树）：（1）由给定的n个权值{w0, w1, w2, …, w n-1}，构造具有n棵二叉树的集合F = {T0, T1, T2, …, T n-1}，其中每一棵二叉树T i只有一个带有权值w i的根结点，其左、右子树均为空。
（2）重复以下步骤, 直到F中仅剩下一棵树为止：① 在F中选取两棵根结点的权值最小的二叉树, 做为左、右子树构造一棵新的二叉树。
置新的二叉树的根结点的权值为其左、右子树上根结点的权值之和。
② 在F中删去这两棵二叉树。
③ 把新的二叉树加入F。
2、用构造赫夫曼树以完成赫夫曼编码：把d1,d2,…, dn作为叶子结点，把w1,w2,…,wn作为叶子结点的权，构造赫夫曼树。
在赫夫曼树中结点的左分支赋0，右分支赋1，从根结点到叶子结点的路径上的数字拼接起来就是这个叶子结点字符的编码。
3、译码的过程是分解电文中的字符串，从根出发，按字符‘0’或‘1’确定找左孩子或右孩子，直至叶子节点，便求得该子串相应的字符。
四、程序的算法描述1、所用存储结构：typedef struct HfNode{int weight;int parent,lchild,rchild;}HfNode,*HuffmanTree; //动态分配数组存储霍夫曼树typedef char **HuffmanCode; //动态分配数组存储霍夫曼编码表2、程序中各函数的简要说明：(1)void Select(HuffmanTree &HT,int i,int &a,int &b)从前i个节点中选择权值最小的两个节点分别存入a,b中。
哈夫曼树的实验报告1
哈夫曼树的实验报告1一、需求分析1、本演示程序实现Haffman编/译码器的作用，目的是为信息收发站提供一个编/译系统，从而使信息收发站利用Haffman编码进行通讯，力求达到提高信道利用率，缩短时间，降低成本等目标。
系统要实现的两个基本功能就是：①对需要传送的数据预先编码；②对从接收端接收的数据进行译码；2、本演示程序需要在终端上读入n个字符（字符型）及其权值（整形），用于建立Huffman树,存储在文件hfmanTree.txt中；如果用户觉得不够清晰还可以打印以凹入表形式显示的Huffman树；3、本演示程序根据建好的Huffman树，对文件的文本进行编码，结果存入文件CodeFile中；然后利用建好的Huffman树将文件CodeFile中的代码进行译码，结果存入文件TextFile中；最后在屏幕上显示代码（每行50个），同时显示对CodeFile中代码翻译后的结果；4、本演示程序将综合使用C++和C语言；5、测试数据：(1)教材例6-2中数据：8个字符，概率分别是0.05，0.29，0.07，0.08，0.14，0.23，0.03，0.11，可将其的权值看为5，29，7，8，14，23，3，11(2)用下表给出的字符集和频度的实际统计数据建立Haffman树，并实现以下报文的编码和一、概要设计1、设定哈夫曼树的抽象数据类型定义ADT Huffmantree{数据对象：D={a i| a i∈Charset,i=1,2,3,……n,n≥0}数据关系：R1＝{< a i-1, a i >| a i-1, a i∈D, i=2,3,……n}基本操作：Initialization(&HT，&HC,w，n,ch)操作结果：根据n个字符及其它们的权值w[i],建立Huffman树HT,用字符数组ch[i]作为中间存储变量，最后字符编码存到HC中；Encodeing(n)操作结果：根据建好的Huffman树，对文件进行编码，编码结果存入到文件CodeFile 中Decodeing(HT,n)操作结果：根据已经编译好的包含n个字符的Huffman树HT，将文件的代码进行翻译，结果存入文件T extFile中} ADT Huffmantree1）主程序模块void main(){输入信息，初始化；选择需要的操作；生成Huffman树；执行对应的模块程序；输出结果；}2）编码模块——根据建成的Huffman树对文件进行编码；3）译码模块——根据相关的Huffman树对编码进行翻译；各模块的调用关系如图所示二、详细设计1、树类型定义typedef struct {unsigned int weight; //权值char ch1; //储存输入的字符unsigned int parent,lchild,rchild;}HTNode,*HuffmanTree;2、编码类型定义typedef char **HuffmanCode;哈夫曼编译器的基本操作设置如下Initialization(HuffmanTree &HT，HuffmanCode &HC,int *w，int &n,char *ch) //根据输入的n个字符及其它们的权值w[i],建立Huffman树HT,用字符数组ch[i]作为中间存储变量存储编码，最后转存到HC中；Encodeing(int n)//根据建好的包含n个字符的Huffman树，对文件进行编码，编码结果存入到文件CodeFile中Decodeing(HuffmanTree HT,int n)//根据已经编译好的包含n个字符的Huffman树HT，对文件的代码进行翻译，结果存入文件TextFile中基本操作操作的算法主函数及其他函数的算法void select(HuffmanTree HT,int n,int &s1,int &s2){ //依次比较，从哈夫曼树的中parent为0的节点中选择出两个权值最小的if(!HT[i].parent&&！HT[S1]&&!HT[S2]){if(HT[i].weight<ht[s1].weight){< p="">s2=s1; s1=i;}else if(HT[i].weight<ht[s2].weight&&i!=s1)< p=""> s2=i;}3、函数的调用关系图三、调试分析Encodeing Decoding Print PrintTreeInitialization1、本次实习作业最大的难点就是文件的读和写，这需要充分考虑到文件里面的格式，例如空格，换行等等，由于不熟悉C++语言和C语言的文件的输入和输出，给编程带来了很大的麻烦；2、原本计划将文本中的换行格式也进行编码，也由于设计函数比较复杂，而最终放弃；3、一开始考虑打印哈夫曼树的凹入表时是顺向思维，希望通过指针的顺序变迁来实现打印，但问题是从根结点到叶子结点的指针不是顺序存储的，所以未能成功，后来查找相关资料，最终利用递归的方法解决问题；4、程序中的数组均采用了动态分配的方法定义，力求达到减少空间的浪费；5、时间的复杂度主要是由查树这个步骤决定，因为无论是编码还是译码都需要对Huffman树进行查找和核对，但考虑到英文字母和空格也就是27个字符，影响不是很大；6、程序无论在屏幕显示还有文件存储方面都达到了不错的效果；7、程序不足的地方就是在文件文本格式方面处理得还是不够，或许可以通过模仿WORD的实现来改善。
哈夫曼树_实验报告
一、实验目的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 字符频率统计首先，需要对待编码的数据进行字符频率统计。
通过扫描数据，记录每个字符出现的次数，得到字符频率。
1.2 构建哈夫曼树根据字符频率构建哈夫曼树，频率较低的字符作为叶子节点，频率较高的字符作为父节点。
构建哈夫曼树的过程中，需要使用最小堆来维护节点的顺序。
1.3 生成编码表通过遍历哈夫曼树，从根节点到每个叶子节点的路径上的左右分支分别赋予0和1，生成对应的编码表。
1.4 数据编码根据生成的编码表，将待编码的数据进行替换，将每个字符替换为对应的编码。
编码后的数据长度通常会减小，实现了数据的压缩。
1.5 数据解码利用生成的编码表，将编码后的数据进行解码，恢复原始数据。
二、实验过程与结果为了验证哈夫曼树编码的有效性，我们选择了一段文本作为实验数据，并进行了以下步骤：2.1 字符频率统计通过扫描文本，统计每个字符出现的频率。
我们得到了一个字符频率表，其中包含了文本中出现的字符及其对应的频率。
2.2 构建哈夫曼树根据字符频率表，我们使用最小堆构建了哈夫曼树。
频率较低的字符作为叶子节点，频率较高的字符作为父节点。
最终得到了一棵哈夫曼树。
2.3 生成编码表通过遍历哈夫曼树，我们生成了对应的编码表。
编码表中包含了每个字符的编码，用0和1表示。
2.4 数据编码将待编码的文本数据进行替换，将每个字符替换为对应的编码。
编码后的数据长度明显减小，实现了数据的压缩。
2.5 数据解码利用生成的编码表，将编码后的数据进行解码，恢复原始文本数据。
数据结构实验三哈夫曼树实验报告
题目：哈夫曼编/译码器一、题目要求：写一个哈夫曼码的编/译码系统，要求能对要传输的报文进行编码和解码。
构造哈夫曼树时，权值小的放左子树，权值大的放右子树，编码时右子树编码为1，左子树编码为0.二、概要设计：数据结构：typedef struct{int bit[MAXBIT];int start;} HCodeType; /* 编码结构体 */typedef struct{int weight;int parent;int lchild;int rchild;char value;} HNode; /* 结点结构体 */函数：void DEMONHuffmanTree (HNode HuffNode[MAXNODE], int n)作用：构造一个哈夫曼树，并循环构建int main ()作用：运用已经构建好的哈弗曼树，进行节点的处理，达到成功解码编译三、详细设计：哈夫曼树的建立：void DEMONHuffmanTree (HNode HuffNode[MAXNODE], int n){int i = 0, j, m1, m2, x1, x2;char x;/* 初始化存放哈夫曼树数组 HuffNode[] 中的结点 */while (i<n){HuffNode[i].weight = 0;//权值HuffNode[i].parent =-1;HuffNode[i].lchild =-1;HuffNode[i].rchild =-1;scanf("%c",&x);scanf("%c",&HuffNode[i].value); //实际值，可根据情况替换为字母i++;}/* 输入 n 个叶子结点的权值 */scanf("%c",&x);for(i=0;i<n;i++){scanf ("%d", &HuffNode[i].weight);}for (i=n; i<2*n-1; i++){HuffNode[i].weight = 0;//权值HuffNode[i].parent =-1;HuffNode[i].lchild =-1;HuffNode[i].rchild =-1;HuffNode[i].value=i;}/* 循环构造 Huffman 树 */for (i=0; i<n-1; i++){m1=m2=MAXQZ; // m1、m2中存放两个无父结点且结点权值最小的两个结点x1=x2=0;//找出所有结点中权值最小、无父结点的两个结点，并合并之为一颗二叉树 for (j=0; j<n+i; j++){if (HuffNode[j].weight < m1 && HuffNode[j].parent==-1){m2=m1;//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;}} /* end for *//* 设置找到的两个子结点 x1、x2 的父结点信息 */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;}}叶子节点的哈夫曼编码的保存：for (j=cd.start+1; j<n; j++)HuffCode[i].bit[j] = cd.bit[j];HuffCode[i].start = cd.start;主函数展示：int main(){HNode HuffNode[MAXNODE];HCodeType HuffCode[MAXLEAF],cd;int i, j, c, p, n,k=0;char wen[100];char z;scanf ("%d", &n);HuffmanTree (HuffNode, n);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;elsecd.bit[cd.start] = 1;cd.start--; /* 求编码的低一位 */c=p;p=HuffNode[c].parent; /* 设置下一循环条件 */} /* end while */for (j=cd.start+1; j<n; j++)HuffCode[i].bit[j] = cd.bit[j];} /* end for */z=getchar();z=getchar();for(;z!='\n';z=getchar()){wen[k++]=z;for(i=0;i<n;i++){if(z==HuffNode[i].value){for (j=HuffCode[i].start+1; j < n; j++)printf ("%d", HuffCode[i].bit[j]);break;}else;}}printf("\n");for(i=0;i<k;i++){printf("%c",wen[i]);}printf("\n");return 0;}四、调试分析与心得体会：虽然哈夫曼树的建立有书上的参考，但是实际写整个代码的时候还是问题重重。
数据结构哈夫曼树实验报告
数据结构哈夫曼树实验报告一、实验内容本次实验的主要内容是哈夫曼树的创建和编码解码。
二、实验目的1. 理解并掌握哈夫曼树的创建过程；2. 理解并掌握哈夫曼编码的原理及其实现方法；3. 掌握哈夫曼树的基本操作，如求哈夫曼编码和哈夫曼解码等；4. 学习如何组织程序结构，运用C++语言实现哈夫曼编码和解码。
三、实验原理哈夫曼树的创建：哈夫曼树的创建过程就是一个不断合并权值最小的两个叶节点的过程。
具体步骤如下：1. 将所有节点加入一个无序的优先队列里；2. 不断地选出两个权值最小的节点，并将它们合并成为一个节点，其权值为这两个节点的权值之和；3. 将新的节点插入到队列中，并继续执行步骤2，直到队列中只剩下一棵树，这就是哈夫曼树。
哈夫曼编码：哈夫曼编码是一种无损压缩编码方式，它根据字符出现的频率来构建编码表，并通过编码表将字符转换成二进制位的字符串。
具体实现方法如下：1. 统计每个字符在文本中出现的频率，用一个数组记录下来；2. 根据字符出现的频率创建哈夫曼树；3. 从根节点开始遍历哈夫曼树，给左分支打上0的标记，给右分支打上1的标记。
遍历每个叶节点，将对应的字符及其对应的编码存储在一个映射表中；4. 遍历文本中的每个字符，查找其对应的编码表，并将编码字符串拼接起来，形成一个完整的编码字符串。
哈夫曼解码就是将编码字符串还原为原始文本的过程。
具体实现方法如下：1. 从根节点开始遍历哈夫曼树，按照编码字符串的位数依次访问左右分支。
如果遇到叶节点，就将对应的字符记录下来，并重新回到根节点继续遍历；2. 重复步骤1，直到编码字符串中的所有位数都被遍历完毕。
四、实验步骤1. 定义编码和解码的结构体以及相关变量；3. 遍历哈夫曼树，得到每个字符的哈夫曼编码，并将编码保存到映射表中；4. 将文本中的每个字符用其对应的哈夫曼编码替换掉，并将编码字符串写入到文件中；5. 使用哈夫曼编码重新构造文本，并将结果输出到文件中。
五、实验总结通过本次实验，我掌握了哈夫曼树的创建和哈夫曼编码的实现方法，也学会了如何用C++语言来组织程序结构，实现哈夫曼编码和解码。
哈夫曼树编码实训报告
一、实训目的本次实训旨在通过实际操作，让学生掌握哈夫曼树的基本概念、构建方法以及编码解码过程，加深对数据结构中树型结构在实际应用中的理解。
通过本次实训，学生能够：1. 理解哈夫曼树的基本概念和构建原理；2. 掌握哈夫曼树的编码和解码方法；3. 熟悉Java编程语言在哈夫曼树编码中的应用；4. 提高数据压缩和传输效率的认识。
二、实训内容1. 哈夫曼树的构建（1）创建叶子节点：根据给定的字符及其权值，创建叶子节点，并设置节点信息。
（2）构建哈夫曼树：通过合并权值最小的两个节点，不断构建新的节点，直到所有节点合并为一棵树。
2. 哈夫曼编码（1）遍历哈夫曼树：从根节点开始，按照左子树为0、右子树为1的规则，记录每个叶子节点的路径。
（2）生成编码：将遍历过程中记录的路径转换为二进制编码，即为哈夫曼编码。
3. 哈夫曼解码（1）读取编码：将编码字符串按照二进制位读取。
（2）遍历哈夫曼树：从根节点开始，根据读取的二进制位，在哈夫曼树中寻找对应的节点。
（3）输出解码结果：当找到叶子节点时，输出对应的字符，并继续读取编码字符串。
三、实训过程1. 准备工作（1）创建一个Java项目，命名为“HuffmanCoding”。
（2）在项目中创建以下三个类：- HuffmanNode：用于存储哈夫曼树的节点信息；- HuffmanTree：用于构建哈夫曼树、生成编码和解码；- Main：用于实现主函数，接收用户输入并调用HuffmanTree类进行编码和解码。
2. 编写代码（1）HuffmanNode类：```javapublic class HuffmanNode {private char data;private int weight;private HuffmanNode left;private HuffmanNode right;public HuffmanNode(char data, int weight) {this.data = data;this.weight = weight;}}```（2）HuffmanTree类：```javaimport java.util.PriorityQueue;public class HuffmanTree {private HuffmanNode root;public HuffmanNode buildHuffmanTree(char[] data, int[] weight) {// 创建优先队列，用于存储叶子节点PriorityQueue<HuffmanNode> queue = new PriorityQueue<>();for (int i = 0; i < data.length; i++) {HuffmanNode node = new HuffmanNode(data[i], weight[i]);queue.offer(node);}// 构建哈夫曼树while (queue.size() > 1) {HuffmanNode left = queue.poll();HuffmanNode right = queue.poll();HuffmanNode parent = new HuffmanNode('\0', left.weight + right.weight);parent.left = left;parent.right = right;queue.offer(parent);}root = queue.poll();return root;}public String generateCode(HuffmanNode node, String code) {if (node == null) {return "";}if (node.left == null && node.right == null) {return code;}generateCode(node.left, code + "0");generateCode(node.right, code + "1");return code;}public String decode(String code) {StringBuilder result = new StringBuilder();HuffmanNode node = root;for (int i = 0; i < code.length(); i++) {if (code.charAt(i) == '0') {node = node.left;} else {node = node.right;}if (node.left == null && node.right == null) { result.append(node.data);node = root;}}return result.toString();}}```（3）Main类：```javaimport java.util.Scanner;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入字符串：");String input = scanner.nextLine();System.out.println("请输入字符及其权值（例如：a 2 b 3 c 5）："); String[] dataWeight = scanner.nextLine().split(" ");char[] data = new char[dataWeight.length / 2];int[] weight = new int[dataWeight.length / 2];for (int i = 0; i < dataWeight.length; i += 2) {data[i / 2] = dataWeight[i].charAt(0);weight[i / 2] = Integer.parseInt(dataWeight[i + 1]);}HuffmanTree huffmanTree = new HuffmanTree();HuffmanNode root = huffmanTree.buildHuffmanTree(data, weight); String code = huffmanTree.generateCode(root, "");System.out.println("编码结果：" + code);String decoded = huffmanTree.decode(code);System.out.println("解码结果：" + decoded);scanner.close();}}```3. 运行程序（1）编译并运行Main类，输入字符串和字符及其权值。
哈夫曼树 实验报告
哈夫曼树实验报告哈夫曼树实验报告引言：哈夫曼树是一种经典的数据结构，广泛应用于数据压缩、编码和解码等领域。
本次实验旨在通过构建哈夫曼树，探索其原理和应用。
一、哈夫曼树的定义和构建方法哈夫曼树是一种特殊的二叉树，其叶子节点对应于待编码的字符，而非叶子节点则是字符的编码。
构建哈夫曼树的方法是通过贪心算法，即每次选择权值最小的两个节点合并，直到构建出完整的哈夫曼树。
二、哈夫曼编码的原理和实现哈夫曼编码是一种可变长度编码，即不同字符的编码长度不同。
其原理是通过构建哈夫曼树来确定字符的编码，使得频率较高的字符编码较短，频率较低的字符编码较长。
这样可以有效地减少编码的长度，从而实现数据的压缩。
三、实验过程和结果在本次实验中，我们选择了一段文本作为输入数据，通过统计每个字符的频率，构建了对应的哈夫曼树。
然后，根据哈夫曼树生成了字符的编码表，并将原始数据进行了编码。
最后，我们通过对编码后的数据进行解码，验证了哈夫曼编码的正确性。
实验结果显示，通过哈夫曼编码后，原始数据的长度明显减少，达到了较好的压缩效果。
同时，解码后的数据与原始数据完全一致，证明了哈夫曼编码的可靠性和正确性。
四、哈夫曼树的应用哈夫曼树在实际应用中有着广泛的用途。
其中，最典型的应用之一是数据压缩。
通过使用哈夫曼编码，可以将大量的数据压缩为较小的存储空间，从而节省了存储资源。
此外，哈夫曼树还被广泛应用于网络传输、图像处理等领域，提高了数据传输的效率和图像的质量。
五、对哈夫曼树的思考哈夫曼树作为一种经典的数据结构，其优势在于有效地减少了数据的冗余和存储空间的占用。
然而，随着技术的不断发展，现代的数据压缩算法已经不再局限于哈夫曼编码，而是采用了更为复杂和高效的算法。
因此，我们需要在实际应用中综合考虑各种因素，选择合适的压缩算法。
六、总结通过本次实验，我们深入了解了哈夫曼树的原理和应用。
哈夫曼编码作为一种重要的数据压缩算法，具有广泛的应用前景。
在实际应用中，我们需要根据具体情况选择合适的压缩算法，以达到最佳的压缩效果和性能。
哈夫曼树实验报告
哈夫曼树实验报告一、实验目的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"。
五、实验总结通过本次实验，我深入了解了哈夫曼树的原理和实现方法，掌握了使用哈夫曼树进行字符编码和解码的过程。
哈夫曼树在数据压缩中的应用非常广泛，能够有效地减小数据的存储空间，提高数据传输效率。
在实际应用中，我们可以根据不同字符出现的频率构建不同的哈夫曼树，从而实现更高效的数据压缩和解压缩算法。
哈夫曼实验报告
一、实验目的1. 理解哈夫曼编码的基本原理和重要性。
2. 掌握哈夫曼树的构建方法。
3. 熟悉哈夫曼编码和译码的实现过程。
4. 分析哈夫曼编码在数据压缩中的应用效果。
二、实验原理哈夫曼编码是一种基于字符频率的编码方法，它利用字符出现的频率来构造一棵最优二叉树（哈夫曼树），并根据该树生成字符的编码。
在哈夫曼树中，频率越高的字符对应的编码越短，频率越低的字符对应的编码越长。
这样，对于出现频率较高的字符，编码后的数据长度更短，从而实现数据压缩。
三、实验内容1. 构建哈夫曼树：- 统计待编码数据中每个字符出现的频率。
- 根据字符频率构建哈夫曼树，其中频率高的字符作为叶子节点，频率低的字符作为内部节点。
- 重复上述步骤，直到树中只剩下一个节点，即为哈夫曼树的根节点。
2. 生成哈夫曼编码：- 从哈夫曼树的根节点开始，对每个节点进行遍历，根据遍历方向（左子树为0，右子树为1）为字符分配编码。
- 将生成的编码存储在编码表中。
3. 编码和译码：- 使用生成的编码表对原始数据进行编码，将编码后的数据存储在文件中。
- 从文件中读取编码后的数据，根据编码表进行译码，恢复原始数据。
四、实验步骤1. 编写代码实现哈夫曼树的构建：- 定义节点结构体，包含字符、频率、左子树、右子树等属性。
- 实现构建哈夫曼树的核心算法，包括节点合并、插入等操作。
2. 实现编码和译码功能：- 根据哈夫曼树生成编码表。
- 编写编码函数，根据编码表对数据进行编码。
- 编写译码函数，根据编码表对数据进行译码。
3. 测试实验效果：- 选择一段文本数据，使用实验代码进行编码和译码。
- 比较编码前后数据的长度，分析哈夫曼编码的压缩效果。
五、实验结果与分析1. 哈夫曼树构建：- 成功构建了哈夫曼树，树中节点按照字符频率从高到低排列。
2. 哈夫曼编码：- 成功生成编码表，字符与编码的对应关系符合哈夫曼编码原理。
3. 编码与译码：- 成功实现编码和译码功能，编码后的数据长度明显缩短，译码结果与原始数据完全一致。
数据结构实验报告(哈夫曼树)
数据结构实验报告实验题目：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中根结点的位置下标。
哈夫曼树试验报告
哈夫曼树实验报告北京邮电大学信息与通信工程学院2009级数据结构实验报告实验名称: 实验三——哈夫曼树学生姓名: 袁彬班级: 2009211119 班班内序号: 09学号: 09210552日期: 2010 年12 月10 日1( 实验要求1.1程序要求(1) 、初始化(Init): 能够对输入的任意长度的字符串s 进行统计，统计每个字符的频度，并建立哈夫曼树。
(2) 、建立编码表(CreateTable): 利用已经建好的哈夫曼树进行编码，并将每个字符的编码输出。
(3) 、编码(Encoding): 根据编码表对输入的字符串进行编码，并将编码后的字符输出。
(4) 、译码(Decoding): 利用已经建好的哈夫曼树对编码后的字符串进行译码，并输出译码结果。
(5) 、计算输入的字符串编码前后的长度，并进行长度分析，讨论哈夫曼树的压缩效果。
测试数据如下:I love data structure,I love computer.I will try my best to study data structure.1.2代码要求(1)、必须要有异常处理，比如删除空链表时要抛出异常(2)、保持良好的编程风格:a.代码之间要有空行和缩进;b.标识符名称应该与其代表意义一致;c.函数名称之间应该添加注释说明该函数的功能;d.关键代码应说明其功能;(3)、递归程序注意调用的过程，防止栈溢出。
2. 程序分析第1页北京邮电大学信息与通信工程学院2.1 存储结构a. 哈夫曼树的存储结构该程序使用一个静态三叉链表来存储哈夫曼树:weight LChild RChild Parent2-1 -1 4 01 3 -1 -1 42 6 -1 -1 539 -1 -1 64 5 1 1 5511 2 2 6620 5 5 -1 b. 哈夫曼编码表的存储结构把每个字符data 及对应的编码code 用一个结点存储，将所有的结点存储在数组中:data CodeZ 100 0C 101 1B 11 23 A 0c. 录入字符串以及存储字符的数组a[] 、b[] 的获取: 先将录入的字符串存在一个字符数组S[] 中，然后遍历数组S[] ，先建立一个空的循环链表，然后再遍历数组S 的同时往链表里插入新的结点或者修改相应结点中的域值: data weight next rear 空循环链表rear2.2关键算法分析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;第2页北京邮电大学信息与通信工程学院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;3. 程序运行结果开始输入一串字符输出编码表否输入字符‘ a'否输入一串‘ 0'、‘1'是是否合法是译码结束第3页北京邮电大学信息与通信工程学院4•总结(1)、出现的问题及调试的方法由于本程序书上有一部分可借鉴的代码，自己只需要编写几个函数即可，但是这几个函数也不是很简单。
数据结构哈夫曼树实验报告
数据结构哈夫曼树实验报告一、实验目的本次实验的主要目的是深入理解和掌握哈夫曼树的数据结构及其相关算法，并通过实际编程实现来提高对数据结构的应用能力和编程技能。
二、实验环境本次实验使用的编程环境为具体编程语言名称，操作系统为具体操作系统名称。
三、实验原理哈夫曼树，又称最优二叉树，是一种带权路径长度最短的二叉树。
其基本原理是通过构建一棵二叉树，使得权值较大的节点距离根节点较近，权值较小的节点距离根节点较远，从而达到带权路径长度最小的目的。
在构建哈夫曼树的过程中，首先需要将所有的节点按照权值从小到大进行排序。
然后，选取权值最小的两个节点作为左右子树，构建一个新的父节点，该父节点的权值为左右子节点权值之和。
重复这个过程，直到所有的节点都被构建到哈夫曼树中。
哈夫曼编码是基于哈夫曼树的一种编码方式。
对于每个叶子节点，从根节点到该叶子节点的路径上，向左的分支编码为 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 对应的编码较长。
实验三 树的应用
华北水利水电学院数据结构实验报告2012～2013学年第一学期2010级计算机科学与技术专业班级：2010134 学号：201013418 姓名：杨学成实验三树的应用一、实验题目：树的应用——哈夫曼编码二、实验内容：利用哈夫曼编码进行通信可以大大提高信道的利用率，缩短信息传输的时间，降低传输成本。
根据哈夫曼编码的原理，编写一个程序，在用户输入结点权值的基础上求哈夫曼编码。
从键盘输入若干字符及每个字符出现的频率，将字符出现的频率作为结点的权值，建立哈夫曼树，求出各字符的哈夫曼编码。
要求：1．输出存放哈夫曼树的数组HT的初态和终态；2．输出每个字符的哈夫曼编码；3．输入由上述若干字符组成的字符串，对电文进行编码并输出；4．（选作）输入电文的哈夫曼编码，进行译码并输出。
三、程序源代码：#include <iostream.h>#include <stdio.h>#include <string.h>#include <stdlib.h>typedef struct{char date;int weight;int parent,lchild,rchild;}HTNode ,*HuffmanTree;typedef char * *HuffmanCode;void Select(HuffmanTree HT,int i,int &s1,int &s2){int m1,m2,k;m1=m2=10000;s1=s2=0;for (k=1;k<=i;k++){if((HT[k].parent==0)&&(HT[k].weight<m1)){m2=m1;s2=s1;m1=HT[k].weight;s1=k;}else if((HT[k].parent==0)&&(HT[k].weight<m2)){m2=HT[k].weight;s2=k;}}}void main (){char str[81],str2[81];HuffmanTree HT;HuffmanCode HC;int w[81], n,i,s1,s2,m,c,f;printf ("请输入编码字符的个数:");scanf("%d",&n);printf("\n编码字符:");cin>>str;printf("\n请输入字符对应的权重:");for (i=0;i<n;i++){scanf("%d",&w[i]);}if(n<=1) return;m=2*n-1;HT=(HuffmanTree) malloc ((m+1)*sizeof(HTNode));for(i=1;i<=n;++i){HT[i].date=str[i-1];HT[i].weight=w[i-1];HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}for(;i<=m;++i){HT[i].date='-';HT[i].weight=0;HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}cout<<" HT的初态"<<endl;cout<<"-------------------------------------------------------------"<<endl;cout<<" date weight parent lchild rchild"<<endl;cout<<"-------------------------------------------------------------"<<endl;for(i=1;i<=m;i++){printf("%4c %4d %4d %4d %4d\n" ,HT[i].date,HT[i].weight,HT[i].parent,HT[i].lchild,HT[i].rchild);cout<<"-----------------------------------------------------------"<<endl;}for (i=n+1;i<=m;++i){Select(HT,i-1,s1,s2);HT[s1].parent=i;HT[s2].parent=i;HT[i].lchild=s1;HT[i].rchild=s2;HT[i].weight=HT[s1].weight+HT[s2].weight;}cout<<" HT的终态"<<endl;cout<<"-------------------------------------------------------------"<<endl;cout<<" date weight parent lchild rchild"<<endl;cout<<"-------------------------------------------------------------"<<endl;for(i=1;i<=m;i++){printf("%4c %4d %4d %4d %4d\n" ,HT[i].date,HT[i].weight,HT[i].parent,HT[i].lchild,HT[i].rchild);cout<<"-------------------------------------------------------------"<<endl;}HC=(HuffmanCode)malloc((n+1)*sizeof(char *));char *cd=(char *)malloc(n*sizeof(char));cd[n-1]='\0';for (i=1;i<=n;++i)int 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';else cd[--start]='1';HC[i]=(char *) malloc ((n-start)*sizeof(char));strcpy(HC[i],&cd[start]);}free(cd);cout<<"字符的编码"<<endl;for (i=1;i<=n;i++){printf("%c : %s\n",HT[i].date,HC[i]);}printf("请输入上述字符组成的任何字符串：");cin>>str2;for (i=0;str2[i]!='\0';i++){for (int j=1;j<=n;j++){if (str2[i]==HT[j].date)cout<<HC[j];}}cout<<endl<<"请输入哈夫曼电文的编码:";cin>>str2;char str4[81];int k=0,tr=0;for (i=0;str2[i]!='\0';i++)int a=i, t=0;char str3[81];tr=0;str3[t]=str2[i];t++;str3[t]='\0';for(;strlen(str3)<n;){for (int j=1;j<=n;j++){if( strcmp(str3,HC[j])==0){str4[k]=HT[j].date;k++;tr=1;}}if (tr==1)break;i++;str3[t]=str2[i];t++;str3[t]='\0';}}if (tr==0){cout<<"It is error.";str4[k]='\0';}else{str4[k]='\0';cout<<str4;}cout<<endl;}四、测试结果：五、小结（包括收获、心得体会、存在的问题及解决问题的方法、建议等）注：内容一律使用宋体五号字，单倍行间距对我来说，数据结构这门课还是有点难度。
哈夫曼树实验报告
一、实验目的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）对给定的文本进行了编码和译码，验证了编码的正确性。
哈夫曼树实训报告
4.2 调试结果................................................................................ 19
5、调试经验...................................................................................... 23
}HFMNode,*HFMTree; typedef char **HuffmanCode; HFMTree HT; char str[N+1]; //定义全局变量 HFMTree 指针 //定义全局变量 str 字符数组，存放 53 个字符
//折半查找，用与频率统计、哈夫曼编码 int BinSearch(char str[N+1],int low,int high,char ch) { int mid; if(low<=high) { mid=(low+high)/2; if(ch==str[mid]) return mid; else if(ch<str[mid]) return BinSearch(str,low,mid-1,ch); else
2、系统分析与设计............................................................................ 5
3、算法设计说明................................................................................ 5
-3-
的长度。但是这种编码方式会出现译码的二义性(又称为多义性)。 例如，E 的使用频率较高，对应的译码为 1，D 使用的频率次之，对应的译码为 10，A 使用的频率又次之，对应的译码为 110。假设接到的编码串为“110'’，是翻译成 “ED”，还是“A”呢?这样就产生了译码的二义性。为了避免译码的二义性，人们规 定，对某一字符集进行不等长编码时，任一个字符的编码都不能是其他字符编码的前 缀。在上例中，E 就是 D 和 A 的前缀。 哈夫曼编码就是一种不等长编码，其定义如下。 对于给定的字符集 D={d1，d2，…，dn}及其频率分布 F={wl，w2，…，wn}，用 d1， d2，…，dn 作为叶节点，wl，w2，…，wn 作为节点的权，利用哈夫曼算法构造一棵最优二 叉树，将树中每个分支节点的左分支标上“0”，右分支标上“1”，把从根到每个叶子 的路径符号(“0”或“1”)连接起来，作为该叶子的编码。由于哈夫曼树是带权路径长度 最小的树，因此采用这种方法得到的编码长度最小。 哈夫曼编码是在哈夫曼树的基础上求出来的，其基本思想是：从叶子节点 di(0≤i<n)出 发，向上回溯至根节点，依次求出每个字符的编码。 哈夫曼编码的回溯步骤如下： (1) 选出哈夫曼树的某一叶子节点。 (2) 利用其双亲指针 parent 找到其双亲节点。 (3) 利用找到的双亲节点的指针域中的 lchild 和 rchild，判断该节点是双亲的左孩子还是 右孩子。若该节点是其双亲节点的左孩子，则生成代码 0；若该节点是其双亲节 点的右孩子，则生成代码 1。 (4) 由于生成的编码与要求的编码反序，将所生成的编码反序。 (5) 重复步骤(1)～(4)，直到所有的节点都回溯完。 在第 4 步中需要将所生成的编码反序，反序的方法是：首先将生成的编码从后向前依 次存放在一个临时的一维数组中，并设一个指针 start 指示编码在该一维数组中的起始位 置。当某个叶子节点的编码完成时，从临时的一维数组的 start 处将编码复制到该字符对 应的 bits 中即可。 哈夫曼树不但可以用来编码，而且还可以用来解码，解码过程正好与编码过程相反。 其解码过程为：从哈夫曼树的根节点出发，依次识别电文中的二进制编码，如果为 0，则 走向左孩子，否则走向其右孩子，走到叶节点时，就可以得到相应的解码字符。 利用哈夫曼编码进行信息通信可以大大提高信道利用率，缩短信息传输时间，降低 传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码；在接收端将 传来的数据进行译码(复原)。对于双工信道(即可以双向传输信息的信道)，每端都需要一 个完整的编僻码系统。试为这样的信息收发站写一个哈夫曼码的编译码系统。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构实验报告实验名称：实验三树学生姓名：班级：班内序号：学号：日期：2012年12月7号1、实验要求利用二叉树结构实现赫夫曼编/解码器。
基本要求：1、初始化(Init)：能够对输入的任意长度的字符串s进行统计，统计每个字符的频度，并建立赫夫曼树2、建立编码表(CreateT able)：利用已经建好的赫夫曼树进行编码，并将每个字符的编码输出。
3、编码(Encoding)：根据编码表对输入的字符串进行编码，并将编码后的字符串输出。
4、译码(Decoding)：利用已经建好的赫夫曼树对编码后的字符串进行译码，并输出译码结果。
5、打印(Print)：以直观的方式打印赫夫曼树（选作）6、计算输入的字符串编码前和编码后的长度，并进行分析，讨论赫夫曼编码的压缩效果。
测试数据：I love data Structure, I love Computer。
I will try my best to study data Structure.提示：1、用户界面可以设计为“菜单”方式：能够进行交互。
2、根据输入的字符串中每个字符出现的次数统计频度，对没有出现的字符一律不用编码。
2、程序分析2.1存储结构（1）二叉树template <class T>class BiTree{public:BiTree(); //构造函数，其前序序列由键盘输入~BiTree(void); //析构函数BiNode<T>* Getroot(); //获得指向根结点的指针protected:BiNode<T> *root; //指向根结点的头指针};//声明类BiTree及定义结构BiNodeData：二叉树是由一个根结点和两棵互不相交的左右子树构成。
二叉树中的结点具有相同数据类型及层次关系。
示意图：lchild parent rchild（2）静态三叉链表struct HNode//哈夫曼树的静态三叉链表 {unsigned int weight; //结点权值unsigned int parent; //双亲指针unsigned int Lchild; //左孩子指针unsigned int Rchild; //右孩子指针};示意图：(3) 编码表的节点结构 struct HCode //字符及其编码结构{char data;char code[100];};示意图：2.2关键算法分析一：关键算法(一)初始化函数void Huffman::Init(int a[],int n)（1）算法自然语言1.创建一个长度为2*n -1的三叉链表2.将存储字符及其权值的链表中的字符逐个写入三叉链表的前n个结点的data域，并将对应结点的孩子域和双亲域赋为空3.从三叉链表的第n个结点开始，i=n3.1从存储字符及其权值的链表中取出两个权值最小的结点x,y，记录其下标x,y。
3.2将下标为x和y的哈夫曼树的结点的双亲设置为第i个结点3.3将下标为x的结点设置为i结点的左孩子，将下标为y的结点设置为i结点的右孩子，i结点的权值为x结点的权值加上y结点的权值，i结点的双亲设置为空4. 根据哈夫曼树创建编码表（2）源代码void Huffman::Init(int a[],int n) //创建哈夫曼树{ //二叉树只有度为和度为的结点时，总结点数为（n-1）个HTree=new HNode[2*n-1]; //根据权重数组a[1—>n]初始化哈夫曼树int i,x,y;for(i=0;i<n;i++) //n个叶子结点{HTree[i].weight=a[i];HTree[i].Lchild=-1;HTree[i].Rchild=-1;HTree[i].parent=-1;}for(int i=n;i<2*n-1;i++) //开始建哈夫曼树，从底层向顶层搭建{SelectMin(HTree,i,x,y); //从--(i-1)中选出两个权值最小的结点HTree[x].parent=i;HTree[y].parent=i; //左右孩子权值相加为父结点的权值HTree[i].weight=HTree[x].weight+HTree[y].weight;HTree[i].Lchild=x;HTree[i].Rchild=y;HTree[i].parent=-1;}}(3)时间复杂度在选取两个权值最小的结点的函数中要遍历链表，时间复杂度为O(n),故该函数的时间复杂度为O（n^2）（二）统计字符出现频度的代码（1）算法自然语言①用cin.getline（）函数获取一段字符串。
同时设置一个权值数组weight，以及暂时统计和存放权值的数组s。
②用strlen（）函数获取未编码时的字符串长度。
③从字符串的起始位置进行权值统计，即获得str[i]每个字符的ASⅡ编码，并在s[(int)str[i]]数组中进行+1统计，为字符出现一次。
④i进行自加，统计下面字符出现的频度，在相应的数组元素中进行+1统计。
⑤继续循环，直到字符串结束。
（2）源代码（在main（）函数中实现）int i,j=0,v;int s[200]={0};int weight[M]; //权值数组cout<<"请输入一段字符串，按回车键结束："<<endl;cin.getline(str,1000,'\n'); //由用户输入一段字符串cout<<endl;Len1=strlen(str); //得到未编码时的字符串长度for(i=0;str[i]!='\0';i++) //统计每个字符的权值s[(int)str[i]]++; //(int)str[i]为每个字符的ASⅡ编码for(i=0;i<200;i++)if(s[i]!=0) //如果权值不为{c[j]=i; //ASⅡ编码为i的字符写入字符数组c weight[j]=s[i]; //权值s数组赋给权值weight数组j++;}n=j; //叶子结点个数for(v=0;v<n;v++) //循环输出字符权值cout<<c[v]<<"的权值为："<<weight[v]<<endl;(3)时间复杂度：若输入的字符串长度为n，则时间复杂度为O(n)（三）选择两个最小权值的函数（1）算法自然语言①先暂时将前两个叶子结点作为权值最小的两个结点i1，i2②从第三个叶子结点开始，每一个结点的权值与i1，i2进行比较，如果此结点权值比i1权值要小，则将i1结点赋给i2，此结点赋给i1。
③如果此结点权值比i2要小，此结点赋给i2。
④每进行一次循环，总结点个数－1.（两个结点进行权值合并）⑤继续执行循环，直到循环到根结点，循环结束。
（2）源代码void Huffman::SelectMin(HNode*hTree,int n,int &i1,int &i2){int i,j; //找一个比较的起始值for(i=0;i<n;i++) //找i1{if(hTree[i].parent==-1){i1=i;break;}}i++;for(;i<n;i++) //找i2{ //先让前两个叶子结点分别为i1，i2if(hTree[i].parent==-1){i2=i;break;}}if(hTree[i1].weight>hTree[i2].weight) //i1指向最小的{j=i2;i2=i1;i1=j;}i++;for(;i<n;i++) //开始找最小的两个{if(hTree[i].parent==-1&&hTree[i].weight<hTree[i1].weight){ //如果之后的叶子结点权值小于前两个，那么进行交换i2=i1; //把i1赋给i2i1=i;}else if(hTree[i].parent==-1&&hTree[i].weight<hTree[i2].weight){i2=i; //始终保证i2权值大于i1}}}（3）时间复杂度若输入的字符串长度为n，则时间复杂度为O(n)（四）创建编码表（1）算法自然语言1.生成一个编码表2.从终端结点开始，如果此结点是其父结点的左孩子，则标“0”；如果是其父结点的右孩子，则标“1”。
3.将父结点赋给孩子结点，并将新的孩子结点的父结点作为当前父结点，重复2操作。
4.继续循环，直到根结点，即不满足循环条件时，将编码表的最后一位置0.5.将编码字符逆置。
将编码串的最后一位置换成新编码串的第一位，倒数第二位置换成新编码串的第二位，直到置换完毕。
6.将新的编码串重新赋给编码表。
7.输出字符的哈夫曼编码。
8.循环将字符编码后的长度赋给Len3数组。
（2）源代码void Huffman::CreateTable(char data[],int n){HCodeTable=new HCode[n]; //生成编码表for(int i=0;i<n;i++){HCodeTable[i].data=data[i];int child=i;int parent=HTree[i].parent;int k=0; //从终端结点开始编码，代表每个编码串的长度while(parent!=-1){if(child==HTree[parent].Lchild)HCodeTable[i].code[k]='0'; //左孩子标“0”elseHCodeTable[i].code[k]='1'; //右孩子标“1”k++;child=parent; //向上追溯parent=HTree[child].parent;}HCodeTable[i].code[k]='\0'; //当编码到根结点时循环结束，编码串最后一位置表结束{ //将编码字符逆置char code[M];int u;for(u=0;u<k;u++)code[u]=HCodeTable[i].code[k-u-1];//上述编码串的最后一位变成新的编码表中编码串的第一位for(u=0;u<k;u++)HCodeTable[i].code[u]=code[u]; //将新的编码串重新赋给编码表cout<<c[i]<<"的哈夫曼编码为：";cout<<HCodeTable[i].code<<endl;Len3[i]=k; //每个字符编码后的长度}}}（3）时间复杂度若输入的字符串长度为n，则时间复杂度为O(n)。