数据结构实验报告哈夫曼树
数据结构哈夫曼编码实验报告
数据结构哈夫曼编码实验报告一、实验目的：通过哈夫曼编、译码算法的实现，巩固二叉树及哈夫曼树相关知识的理解掌握，训练学生运用所学知识，解决实际问题的能力。
二、实验内容：已知每一个字符出现的频率，构造哈夫曼树，并设计哈夫曼编码。
1、从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树。
2、打印每一个字符对应的哈夫曼编码。
3、对从终端读入的字符串进行编码，并显示编码结果。
4、对从终端读入的编码串进行译码，并显示译码结果。
三、实验方案设计：（对基本数据类型定义要有注释说明，解决问题的算法思想描述要完整，算法结构和程序功能模块之间的逻辑调用关系要清晰，关键算法要有相应的流程图，对算法的时间复杂度要进行分析）1、算法思想：（1）构造两个结构体分别存储结点的字符及权值、哈夫曼编码值：（2）读取前n个结点的字符及权值，建立哈夫曼树：（3）根据哈夫曼树求出哈夫曼编码：2、算法时间复杂度：（1）建立哈夫曼树时进行n到1次合并，产生n到1个新结点，并选出两个权值最小的根结点：O（n²）；（2）根据哈夫曼树求出哈夫曼编码：O（n²）。
（3）读入电文，根据哈夫曼树译码：O（n）。
四、该程序的功能和运行结果：（至少有三种不同的测试数据和相应的运行结果，充分体现该程序的鲁棒性）1、输入字符A，B，C，D，E，F及其相应权值16、12、9、30、6、3。
2、输入字符F，E，N，G，H，U，I及其相应权值30、12、23、22、12、7、9。
3、输入字符A，B，C，D，E，F，G，H，I，G及其相应权值19、23、25、18、12、67、23、9、32、33。
哈夫曼树_实验报告
一、实验目的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. 实验结果分析通过实验，验证了哈夫曼树和哈夫曼编码的正确性。
数据结构 哈夫曼编码实验报告
数据结构哈夫曼编码实验报告数据结构哈夫曼编码实验报告1. 实验目的本实验旨在通过实践理解哈夫曼编码的原理和实现方法，加深对数据结构中树的理解，并掌握使用Python编写哈夫曼编码的能力。
2. 实验原理哈夫曼编码是一种用于无损数据压缩的算法，通过根据字符出现的频率构建一棵哈夫曼树，并根据哈夫曼树对应的编码。
根据哈夫曼树的特性，频率较低的字符具有较长的编码，而频率较高的字符具有较短的编码，从而实现了对数据的有效压缩。
实现哈夫曼编码的主要步骤如下：1. 统计输入文本中每个字符的频率。
2. 根据字符频率构建哈夫曼树，其中树的叶子节点代表字符，内部节点代表字符频率的累加。
3. 遍历哈夫曼树，根据左右子树的关系对应的哈夫曼编码。
4. 使用的哈夫曼编码对输入文本进行编码。
5. 将编码后的二进制数据保存到文件，同时保存用于解码的哈夫曼树结构。
6. 对编码后的文件进行解码，还原原始文本。
3. 实验过程3.1 统计字符频率首先，我们需要统计输入文本中每个字符出现的频率。
可以使用Python中的字典数据结构来记录字符频率。
遍历输入文本的每个字符，将字符添加到字典中，并递增相应字符频率的计数。
```pythondef count_frequency(text):frequency = {}for char in text:if char in frequency:frequency[char] += 1else:frequency[char] = 1return frequency```3.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.实验目的本实验旨在研究哈夫曼编码的原理和实现方法，通过实验验证哈夫曼编码在数据压缩中的有效性，并分析其应用场景和优缺点。
2.实验原理2.1 哈夫曼编码哈夫曼编码是一种无损数据压缩算法，通过根据字符出现的频率构建一颗哈夫曼树，将频率较高的字符用较短的编码表示，频率较低的字符用较长的编码表示。
哈夫曼编码的编码表是唯一的，且能够实现前缀编码，即一个编码不是另一个编码的前缀。
2.2 构建哈夫曼树构建哈夫曼树的过程如下：1) 将每个字符及其频率作为一个节点，构建一个节点集合。
2) 每次从节点集合中选择出现频率最低的两个节点，构建一个新节点，并将这两个节点从集合中删除。
3) 将新节点加入节点集合。
4) 重复以上步骤，直到节点集合中只有一个节点，这个节点就是哈夫曼树的根节点。
2.3 编码过程根据哈夫曼树，对每个字符进行编码：1) 从根节点开始，根据左子树为0，右子树为1的规则，将编码依次加入编码表。
2) 对于每个字符，根据编码表获取其编码。
3) 将编码存储起来，得到最终的编码序列。
3.实验步骤3.1 数据读取与统计从输入文件中读取字符序列，并统计各个字符的频率。
3.2 构建哈夫曼树根据字符频率构建哈夫曼树。
3.3 构建编码表根据哈夫曼树，构建每个字符的编码表。
3.4 进行编码根据编码表，对输入的字符序列进行编码。
3.5 进行解码根据哈夫曼树，对编码后的序列进行解码。
4.实验结果与分析4.1 压缩率分析计算原始数据和压缩后数据的比值，分析压缩率。
4.2 编码效率分析测试编码过程所需时间，分析编码效率。
4.3 解码效率分析测试解码过程所需时间，分析解码效率。
4.4 应用场景分析分析哈夫曼编码在实际应用中的优势和适用场景。
5.结论通过本次实验，我们深入了解了哈夫曼编码的原理和实现方法，实践了哈夫曼编码的过程，并对其在数据压缩中的有效性进行了验证。
实验结果表明，哈夫曼编码能够实现较高的压缩率和较高的编解码效率。
哈夫曼树实验报告 (2)
三、实验要求
设计思路: 数据结构: #ｄefiｎe n １00ﻩﻩ//叶子结点数 #ｄeｆine m 2*n－1// Huffman 树中结点总数 typedef strucｔ {
ﻩiｎt ｗｅight； /／权值 ﻩｉｎt lchild , rｃhilｄ , parent; ／/左右孩子及双亲指针
scanf （"%ｄ＂，w＋ｉ);
HuffｍanCoｄiｎg(HＴ,HC，w,n）;
fｏr（i=１;i<=n;ｉ++)｛
printf("对应得编码为:")；
puts(ＨC[i]）;｝
}
}
//*＊＊＊从叶子到根逆向求每个字符得赫夫曼编码****
ＨC=(HuｆｆmanCode)mａlloc((ｎ+１）*sizeof（chaｒ*));/／分配ｎ个字符编码得头指针向量
ｃd=(cｈaｒ＊)ｍａlloｃ(n*ｓizeｏf（ｃhａr));
//分配求编码得工作区间
cd[n-1]='\０';
//编码结束符
else ｃｄ[--sｔart]='１＇;
HC[i］=(char *)mａlloc((n－staｒt)*sｉｚeof(cｈaｒ）); //为第ｉ个字符编码分配空间
stｒcpy（HC[i],&cｄ[ｓtarｔ]）；
//从 cd 复制编码(串）到 HC
｝
free(ｃd）;
//释放空间
｝
vｏid ｍain()
foｒ（i＝1;ｉ<＝n；++i）
/／逐个字符求赫夫曼树编码
{ int staｒt;
stａrt=n-1;
//编码结束符位置
数据结构实验三哈夫曼树实验报告
int i, j, c, p, n,k=0;
char wen [100];
char z;
scanf ("%d", &n);
Huffma nTree (HuffNode, n);
for (i=0; i < n; i++)
{
cd.start = n-1;
{
m2=m1;//m1中是最小
x2=x1;
m仁Hu ffNode[j].weight;
x1=j;
}
else if (HuffNode[j].weight < m2 && HuffNode[j].parent==-1) {
m2=HuffNode[j].weight;
x2=j;
} /* end for */
题目：哈夫曼编/译码器
一、题目要求：
写一个哈夫曼码的编/译码系统，要求能对要传输的报文进行编码和解码。 子树，权值大的放右子树，编码时右子树编码为1左子树编码为0.
构造哈夫曼树时，
权值小的放左
、概要设计:
数据结构：
typedef struct
{
int bit[MAXBIT];
int start;
} HCodeType; /*
{
HuffNode[i].weight = 0;//权值
HuffNode[i].pare nt =-1;
HuffNode[i].lchild =-1;
HuffNode[i].rchild =-1;
HuffNode[i].value=i;
}
/*循环构造Huffman树*/
哈夫曼树实验报告
哈夫曼树实验报告一、实验目的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、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构实验报告实验题目: 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中根结点的位置下标。
5.void InitStack(SqStack &S);此函数用于初始化一个栈。
6.void Pop(SqStack &S,char e);此函数为出栈操作。
7.void Push(SqStack &S,char e);此函数为进栈操作。
8.int StackLength(SqStack S);此函数用于求栈长,返回一个int型的值。
9.int Find(char a,char s[],int num);此函数用于查找字符a在电文串中的位置。
10.int Recover(HuffmanTree HT,char **HC,char string[],char a[],char b[],int n);此函数用于将比特流还原成电文。
调试分析:输入任意一个字符串,如输入welcometoustc:运行结果如下:按照提示输入任意一个或多个哈弗曼编码,如输入11111110101:结果正确。
若输入一个11111:结果正确。
实验完成！实验体会与收获:本次实验提高了对哈弗曼树的认识,同时加深了对二叉树的理解,在栈的运用上更加熟练,对数组的应用也有了提高。
源代码:#include<stdio、h>#include<stdlib、h>#include<malloc、h>#include<string、h>typedef struct{int weight;int parent,lc,rc;}HTNode,*HuffmanTree;typedef struct LNode{char *elem;int stacksize;int top;}SqStack;#define size 20void HuffTree(HuffmanTree &HT,int n[],int mun);void Select(HuffmanTree &HT,int n,int i,int &s1,int &s2);void HuffmanCoding(HuffmanTree HT,char **&HC,int n);void Coding(HuffmanTree HT,char **HC,int root,SqStack &S);void InitStack(SqStack &S);void Pop(SqStack &S,char e);void Push(SqStack &S,char e);int StackLength(SqStack S);int Find(char a,char s[],int num);int Recover(HuffmanTree HT,char **HC,char string[],char a[],char b[],int n); int main(){int i=0,n[size]={0},j=0,k=1,num=0;char string[size]={0},m[size]={0},a[size]={0},b[size]={0};char** HC;HuffmanTree HT;printf("请输入电文串:\n");scanf("%s",string);strcpy(m,string);while(string[j]){if(string[j]!='#') a[k]=string[j];i=j;while(string[i]){if(string[i]==a[k]){string[i]='#';n[k]++;}i++;}if(n[k]!=0){printf("该电文中字符%c出现次数为%d\n",a[k],n[k]);num++;k++;}j++;}printf("哈弗曼树:\n");HuffTree(HT,n,num);for(i=1;i<=2*num-1;i++) printf("%d\t%d\t%d\t%d\n",HT[i]、weight,HT[i]、parent,HT[i]、lc,HT[i]、rc);printf("哈弗曼编码:\n");HuffmanCoding(HT,HC,num);for(i=1;i<=num;i++){printf("%c : %s\n",a[i],HC[i]);}printf("\n该电文的哈弗曼编码为:\n");i=0;while(string[i])printf("%s",HC[Find(m[i++],a,num)]);printf("\n请输入哈弗曼编码:\n");scanf("%s",string);if(Recover(HT,HC,string,a,b,num)) printf("%s\n",b);else printf("代码有误!\n");system("pause");return 0;}void HuffTree(HuffmanTree &HT,int n[],int num){int i,m,s1,s2;m=2*num-1;HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));for(i=1;i<=m;i++){HT[i]、weight=i<=num?n[i]:0;HT[i]、lc=HT[i]、rc=HT[i]、parent=0;}for(i=num+1;i<=m;i++){Select(HT,num,i,s1,s2);HT[i]、lc=s1;HT[i]、rc=s2;HT[i]、weight=HT[s1]、weight+HT[s2]、weight;HT[s1]、parent=HT[s2]、parent=i;}}void Select(HuffmanTree &HT,int n,int i,int &s1,int &s2){int k,t;s1=s2=-1;k=1;while(s1==-1){if(HT[k]、parent==0)s1=k;k++;}k=1;while(s2==-1||s2==s1){if(HT[k]、parent==0)s2=k;k++;}if(HT[s2]、weight<HT[s1]、weight){t=s2;s2=s1;s1=t;}for(k=1;k<i;k++){if(HT[k]、parent==0){if(HT[k]、weight<HT[s1]、weight&&k!=s1&&k!=s2){s2=s1;s1=k;}else if(HT[k]、weight<HT[s2]、weight&&HT[k]、weight>=HT[s1]、weight&&k!=s1&&k!=s2) s2=k;}}}void HuffmanCoding(HuffmanTree HT,char **&HC,int n){SqStack S;InitStack(S);HC=(char**)malloc((n+1)*sizeof(char*));Coding(HT,HC,2*n-1,S);}void Coding(HuffmanTree HT,char **HC,int root,SqStack &S){if(root!=0){if(HT[root]、lc==0){Push(S,'\0');HC[root]=(char*)malloc((StackLength(S)));strcpy(HC[root],S、elem);Pop(S,'\0');}Push(S,'0');Coding(HT,HC,HT[root]、lc,S);Pop(S,'\0');Push(S,'1');Coding(HT,HC,HT[root]、rc,S);Pop(S,'\0');}}void InitStack(SqStack &S){S、elem=(char *)malloc(size*sizeof(char));S、stacksize=size;S、top=-1;}void Push(SqStack &S,char e){S、elem[++S、top]=e;}void Pop(SqStack &S,char e){if(S、top==-1) return;e=S、elem[S、top--];return;}int StackLength(SqStack S){if(S、top==-1) return(0);return(S、top);}int Find(char a,char s[],int num){int i;for(i=1;i<=num;i++)if(a==s[i]) return i;return 0;}int Recover(HuffmanTree HT,char **HC,char string[],char a[],char b[],int n) {int i=0,j=0,k,m=0,t=0,h=0;char s[size];k=2*n-1;while(string[i]){if(!HT[k]、lc&&!HT[k]、rc){if(string[i]=='0') {s[j]='\0';k=2*n-1;t=1;j=0;}if(string[i]=='1'){s[j]='\0';k=2*n-1;t=1;j=0;}for(h=1;h<=n;h++)if(!strcmp(HC[h],s))b[m++]=a[h];}else{if(string[i]=='0') {k=HT[k]、lc;s[j++]='0';}if(string[i]=='1'){k=HT[k]、rc;s[j]='1';j++;}t=0;}if(!t)i++;}if(!HT[k]、lc&&!HT[k]、rc){if(string[i-1]=='0') {s[j]='\0';k=2*n-1;j=0;}if(string[i-1]=='1'){s[j]='\0';k=2*n-1;t=1;j=0;}for(h=1;h<=n;h++)if(!strcmp(HC[h],s))b[m++]=a[h];}b[m]='\0';if(k==2*n-1) return 1;else return 0;}。