C语言知识学习-哈夫曼编码实验报告
哈夫曼编码的实验报告
哈夫曼编码的实验报告哈夫曼编码的实验报告一、引言信息的传输和存储是现代社会中不可或缺的一部分。
然而，随着信息量的不断增加，如何高效地表示和压缩信息成为了一个重要的问题。
在这个实验报告中，我们将探讨哈夫曼编码这一种高效的信息压缩算法。
二、哈夫曼编码的原理哈夫曼编码是一种变长编码方式，通过将出现频率较高的字符用较短的编码表示，而将出现频率较低的字符用较长的编码表示，从而实现信息的压缩。
它的核心思想是利用统计特性，将出现频率较高的字符用较短的编码表示，从而减少整体编码长度。
三、实验过程1. 统计字符频率在实验中，我们首先需要统计待压缩的文本中各个字符的出现频率。
通过遍历文本，我们可以得到每个字符出现的次数。
2. 构建哈夫曼树根据字符频率，我们可以构建哈夫曼树。
哈夫曼树是一种特殊的二叉树，其中每个叶子节点代表一个字符，并且叶子节点的权值与字符的频率相关。
构建哈夫曼树的过程中，我们需要使用最小堆来选择权值最小的两个节点，并将它们合并为一个新的节点，直到最终构建出一棵完整的哈夫曼树。
3. 生成编码表通过遍历哈夫曼树，我们可以得到每个字符对应的编码。
在遍历过程中，我们记录下每个字符的路径，左边走为0，右边走为1，从而生成编码表。
4. 进行编码和解码在得到编码表后，我们可以将原始文本进行编码，将每个字符替换为对应的编码。
编码后的文本长度将会大大减少。
为了验证编码的正确性，我们还需要进行解码，将编码后的文本还原为原始文本。
四、实验结果我们选取了一段英文文本作为实验数据，并进行了哈夫曼编码。
经过编码后，原始文本长度从1000个字符减少到了500个字符。
解码后的文本与原始文本完全一致，验证了哈夫曼编码的正确性。
五、讨论与总结哈夫曼编码作为一种高效的信息压缩算法，具有广泛的应用前景。
通过将出现频率较高的字符用较短的编码表示，哈夫曼编码可以在一定程度上减小信息的存储和传输成本。
然而，哈夫曼编码也存在一些局限性，例如对于出现频率相近的字符，编码长度可能会相差较大。
赫夫曼编码实验报告
实验五哈夫曼树和哈夫曼树编码学院专业班学号姓名一．实习目的1.掌握哈夫曼树的顺序存储方式；2.掌握建立哈夫曼树的方法；3.掌握由哈夫曼树构造哈夫曼编码的方法。
二．实习内容1.建立哈夫曼树的顺序存储结构；2.编程实现构建一棵哈夫曼树。
3.编程实现由哈夫曼树构造出哈夫曼编码三．实习步骤1. 程序代码#include<malloc.h> // malloc()等#include<limits.h> // INT_MAX等#include<stdio.h> //#include<stdlib.h> //#include<string.h>typedef struct{unsigned int weight;unsigned int parent,lchild,rchild;}HTNode,*HuffmanTree; // 动态分配数组存储赫夫曼树typedef char **HuffmanCode; // 动态分配数组存储赫夫曼编码表int min(HuffmanTree t,int i){ // 返回i个结点中权值最小的树的根结点序号，函数select()调用int j,flag;unsigned int k=UINT_MAX; // 取k为不小于可能的值(无符号整型最大值) for(j=1;j<=i;j++)if(t[j].weight<k&&t[j].parent==0) // t[j]是树的根结点k=t[j].weight,flag=j;t[flag].parent=1; // 给选中的根结点的双亲赋1，避免第2次查找该结点return flag;}void select(HuffmanTree t,int i,int &s1,int &s2){ // 在i个结点中选择2个权值最小的树的根结点序号，s1为其中序号小的那个int j;s1=min(t,i);s2=min(t,i);if(s1>s2){j=s1;s1=s2;s2=j;}}void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n) // 算法6.12{ // w存放n个字符的权值(均>0)，构造赫夫曼树HT，并求出n个字符的赫夫曼编码HC int m,i,s1,s2,start;unsigned c,f;HuffmanTree p;char *cd;if(n<=1)return;m=2*n-1;HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode)); // 0号单元未用for(p=HT+1,i=1;i<=n;++i,++p,++w){(*p).weight=*w;(*p).parent=0;(*p).lchild=0;(*p).rchild=0;}for(;i<=m;++i,++p)(*p).parent=0;for(i=n+1;i<=m;++i) // 建赫夫曼树{ // 在HT[1～i-1]中选择parent为0且weight最小的两个结点，其序号分别为s1和s2 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;}// 从叶子到根逆向求每个字符的赫夫曼编码HC=(HuffmanCode)malloc((n+1)*sizeof(char*));// 分配n个字符编码的头指针向量([0]不用)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));// 为第i个字符编码分配空间strcpy( HC[i], &cd [start] ); // 从cd复制编码(串)到HC}free(cd); // 释放工作空间}void main(){HuffmanTree HT;HuffmanCode HC;int *w,n,i;printf("请输入权值的个数(>1): ");scanf("%d",&n);w=(int*)malloc(n*sizeof(int));printf("请依次输入%d个权值(整型):\n",n);for(i=0;i<=n-1;i++)scanf("%d",w+i);HuffmanCoding(HT,HC,w,n);printf("huffman树存储结构：\n");for( i=1;i<2*n;i++)printf("%4d%4d%4d%4d\n", HT[i].weight,HT[i].parent,HT[i].lchild,HT[i].rchild);// 输出哈夫曼树的每个结点的权值、父亲结点序号、左孩子和右孩子序号。
实习报告6_哈夫曼编码
1.初始化：从文件（程序运行时，由用户输入）读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，将它存于文件中。
2.编码：利用已建好的哈夫曼树（如不在内存，则从文件中读入）对文件字符集中的每一个进行编码，将结果放在中。
3.译码：利用已建好的哈夫曼树将中的代码进行译码，结果保存在中。
4.印代码文件。
将文件以紧凑的格式显示在终端上，每行50个代码。
同时将结果保存在中。
二.概要设计：1.哈夫曼树的抽象数据类型定义：ADT haffman{ 数据对象：D={ai|ai为charnode型的结点，i=1，2，3，……n，n>0}数据关系：R={<ai,><ai,>|ai是D上的元素}} ADT haffman2.编码集结构体的抽象数据类型的定义：ADT code{ 数据对象：D1={ai| ai是charlink型的结点，i=1，2，……n，n>0}D2={bi|bi是codelink型的结点，i=1，2，……n，n>0}数据关系： R1={<ai,>|ai是D1上的元素}R2={<bi,>|bi是D2上的元素}} ADT code3.程序分为四个部分：1）读入字符集以及相应频度，建立哈夫曼树。
2）根据哈夫曼树得到每一个字符的哈夫曼编码。
3）读入要编码的字符串，根据哈夫曼树和编码集求出字符串的哈夫曼编码。
4）根据哈夫曼编码和哈夫曼树得到字符串。
三.详细设计：h >> hufW[ ii ].wt;}(); .eight<< setw( 8 ) << hufT[ tOut ].parent<< setw( 8 ) << hufT[ tOut ].lChild<< setw( 8 ) << hufT[ tOut ].rChild << endl;}hufTreeOutPut << "-- end HT --------------------------- " << endl << endl << "-- HC ------------------------------- " << endl;for( int cOut = 1 ; cOut <= hufNum ; cOut++ ){hufTreeOutPut << " " << hufC[ cOut ].ch << " ---->> " << hufC[ cOut ].hufCh << endl;}hufTreeOutPut << "-- convert -- ok -------------------- " << endl;(); t;p->parent = p->lChild = p->rChild = 0; i-1 ]选择parent 为 0 且weight 最小的两个结点，其序号分别为 s1 和 s2arent = i; arent = i; Child = s1; Child = s2; eight =HT[ s1 ].weight + HT[ s2 ].weight; arent ; f != 0 ; c = f , f =HT[ f ].parent ) Child == c ) { cd[ --start ] = '0'; }else { cd[ --start ] = '1'; }}HC[ i ].ch = w[ i-1 ].ch ; ufCh = ( char* ) malloc ( ( n - start ) * sizeof( char ) ); ufCh , &cd[ start ] ); arent != 0 ) continue;else{sm1 = HT[ m ].weight;s1=m;break;}}for( int j = m+1 ; j <= i ; j++ ) arent != 0 ) continue;else{if( sm1 > HT[ j ].weight ){sm1 = HT[ j ].weight;s1 = j;}}}for( m = 1 ; m <= i ; m++ ) arent != 0 ) continue;else{sm2 = HT[ m ].weight;s2=m;if( s2 == s1 ) continue;else break;}}for( int k = m+1 ; k <= i ; k++ ) arent != 0 ) continue;else{if( (HT[ k ].weight < sm2) && ( k != s1 ) ) eight;s2 = k;}}}} ufCh == ' 'fOut << HC[ sub ].hufCh;}else if( inBuf == '\n' ){continue;}else{ufCh == 'A'. 以下的字符雷同sub = inBuf - 63;fOut << HC[ sub ].hufCh;}}HT[p]就为 HT 的根.Child != 0 ) Child; ufCh , cd ) == 0 ){fOut << HC[ iHC ].ch;break; Child; Child != 0 ) Child; ufCh , cd ) == 0 ){fOut << HC[ iHC ].ch;break; Child; ufCh , cd ) == 0 ){fOut << HC[ iHC ].ch;break; ufCh , cd ) == 0 ){fOut << HC[ iHC ].ch;break; 试分析1.本次作业在打印树形结构的时候有点遗憾，其他的都应该做的完美的了。
哈夫曼编码译码器实验报告
哈夫曼编码译码器实验报告实验名称：哈夫曼编码译码器实验一、实验目的：1.了解哈夫曼编码的原理和应用。
2.实现一个哈夫曼编码的编码和译码器。
3.掌握哈夫曼编码的编码和译码过程。
二、实验原理：哈夫曼编码是一种常用的可变长度编码，用于将字符映射到二进制编码。
根据字符出现的频率，建立一个哈夫曼树，出现频率高的字符编码短，出现频率低的字符编码长。
编码过程中，根据已建立的哈夫曼树，将字符替换为对应的二进制编码。
译码过程中，根据已建立的哈夫曼树，将二进制编码替换为对应的字符。
三、实验步骤：1.构建一个哈夫曼树，根据字符出现的频率排序。
频率高的字符在左子树，频率低的字符在右子树。
2.根据建立的哈夫曼树，生成字符对应的编码表，包括字符和对应的二进制编码。
3.输入一个字符串，根据编码表将字符串编码为二进制序列。
4.输入一个二进制序列，根据编码表将二进制序列译码为字符串。
5.比较编码前后字符串的内容，确保译码正确性。
四、实验结果：1.构建哈夫曼树：-字符出现频率：A(2)，B(5)，C(1)，D(3)，E(1) -构建的哈夫曼树如下：12/\/\69/\/\3345/\/\/\/\ABCDE2.生成编码表：-A:00-B:01-C:100-D:101-E:1103.编码过程：4.译码过程：5.比较编码前后字符串的内容，结果正确。
五、实验总结：通过本次实验，我了解了哈夫曼编码的原理和应用，并且实现了一个简单的哈夫曼编码的编码和译码器。
在实验过程中，我充分运用了数据结构中的树的知识，构建了一个哈夫曼树，并生成了编码表。
通过编码和译码过程，我进一步巩固了对树的遍历和节点查找的理解。
实验结果表明，本次哈夫曼编码的编码和译码过程正确无误。
在实验的过程中，我发现哈夫曼编码对于频率较高的字符具有较短的编码，从而实现了对字符串的高效压缩。
同时，哈夫曼编码还可以应用于数据传输和存储中，提高数据的传输效率和存储空间的利用率。
通过本次实验，我不仅掌握了哈夫曼编码的编码和译码过程，还深入了解了其实现原理和应用场景，加深了对数据结构和算法的理解和应用能力。
数据结构 哈夫曼编码实验报告(2023版)
数据结构哈夫曼编码实验报告实验目的：本实验旨在了解和实现哈夫曼编码算法，通过将字符转换为对应的哈夫曼编码来实现数据的压缩和解压缩。
一、引言1.1 背景介绍哈夫曼编码是一种基于字符出现频率的编码方法，通过使用不等长编码来表示不同字符，从而实现数据的高效压缩。
该编码方法在通信、存储等领域有着广泛的应用。
1.2 目标本实验的目标是实现哈夫曼编码算法，通过对给定文本进行编码和解码，验证哈夫曼编码的有效性和可靠性。
二、实验过程2.1 数据结构设计在实现哈夫曼编码算法时，我们需要设计合适的数据结构来存储字符和对应的编码。
常用的数据结构包括树和哈希表。
我们将使用二叉树作为数据结构来表示字符的编码。
2.2 构建哈夫曼树哈夫曼树是由给定字符集合构建而成的最优二叉树。
构建哈夫曼树的过程分为两步：首先根据字符出现频率构建叶子节点，然后通过合并叶子节点和父节点构造哈夫曼树。
2.3 哈夫曼编码表根据构建好的哈夫曼树，我们可以对应的哈夫曼编码表。
哈夫曼编码表由字符和对应的编码组成，可以用于字符的编码和解码。
2.4 文本压缩利用的哈夫曼编码表，我们可以对给定的文本进行压缩。
将文本中的字符逐个替换为对应的哈夫曼编码，从而实现数据的压缩。
2.5 文本解压缩对压缩后的数据进行解压缩时，我们需要利用的哈夫曼编码表，将哈夫曼编码逐个替换为对应的字符，从而还原出原始的文本数据。
三、实验结果我们使用不同长度、不同频率的文本进行了实验。
实验结果表明，哈夫曼编码在数据压缩方面有着显著的效果，可以大大减小数据存储和传输的开销。
四、实验总结通过本实验，我们深入理解了哈夫曼编码算法的原理和实现过程，掌握了数据的压缩和解压缩技术。
哈夫曼编码作为一种经典的数据压缩算法，具有重要的理论意义和实际应用价值。
附件：本文档附带哈夫曼编码实验的源代码和实验数据。
法律名词及注释：在本文档中，涉及的法律名词和注释如下：1.哈夫曼编码：一种数据压缩算法，用于将字符转换为可变长度的编码。
哈夫曼编码实验报告
哈夫曼编码实验报告霍夫曼（Huffman）编码属于码词长度可变的编码类，是霍夫曼在1952年提出的一种编码方法，即从下到上的编码方法。
同其他码词长度可变的编码一样，可区别的不同码词的生成是基于不同符号出现的不同概率。
生成霍夫曼编码算法基于一种称为“编码树”（coding tree）的技术。
算法步骤如下：（1）初始化，根据符号概率的大小按由大到小顺序对符号进行排序。
（2）把概率最小的两个符号组成一个新符号（节点），即新符号的概率等于这两个符号概率之和。
（3）重复第2步，直到形成一个符号为止（树），其概率最后等于1。
（4）从编码树的根开始回溯到原始的符号，并将每一下分枝赋值为1，上分枝赋值为0。
以下这个简单例子说明了这一过程。
1)．字母A,B,C,D,E已被编码，相应的出现概率如下：p(A)=0.16, p(B)=0.51, p(C)=0.09, p(D)=0.13, p(E)=0.11 2)．C和E概率最小，被排在第一棵二叉树中作为树叶。
它们的根节点CE的组合概率为0.20。
从CE到C的一边被标记为1，从CE到E的一边被标记为0。
这种标记是强制性的。
所以，不同的哈夫曼编码可能由相同的数据产生。
3)．各节点相应的概率如下：p(A)=0.16, p(B)=0.51, p(CE)=0.20, p(D)=0.13D和A两个节点的概率最小。
这两个节点作为叶子组合成一棵新的二叉树。
根节点AD的组合概率为0.29。
由AD到A的一边标记为1，由AD到D的一边标记为0。
如果不同的二叉树的根节点有相同的概率，那么具有从根到节点最短的最大路径的二叉树应先生成。
这样能保持编码的长度基本稳定。
4)．剩下节点的概率如下：p(AD)=0.29, p(B)=0.51, p(CE)=0.20AD和CE两节点的概率最小。
它们生成一棵二叉树。
其根节点ADCE 的组合概率为0.49。
由ADCE到AD一边标记为0，由ADCE到CE 的一边标记为1。
哈夫曼编码 实验报告
哈夫曼编码实验报告哈夫曼编码实验报告一、引言哈夫曼编码是一种用于数据压缩的算法，由大卫·哈夫曼于1952年提出。
它通过将出现频率高的字符用较短的编码表示，从而实现对数据的高效压缩。
本实验旨在通过实际操作和数据分析，深入了解哈夫曼编码的原理和应用。
二、实验目的1. 掌握哈夫曼编码的基本原理和算法；2. 实现哈夫曼编码的压缩和解压缩功能；3. 分析不同数据集上的压缩效果，并对结果进行评估。
三、实验过程1. 数据集准备本实验选取了三个不同的数据集，分别是一篇英文文章、一段中文文本和一段二进制数据。
这三个数据集具有不同的特点，可以用来评估哈夫曼编码在不同类型数据上的压缩效果。
2. 哈夫曼编码实现在实验中，我们使用了Python编程语言来实现哈夫曼编码的压缩和解压缩功能。
首先，我们需要统计数据集中各个字符的出现频率，并构建哈夫曼树。
然后，根据哈夫曼树生成每个字符的编码表，将原始数据转换为对应的编码。
最后，将编码后的数据存储为二进制文件，并记录编码表和原始数据的长度。
3. 压缩效果评估对于每个数据集，我们比较了原始数据和压缩后数据的大小差异，并计算了压缩比和压缩率。
压缩比是指压缩后数据的大小与原始数据大小的比值，压缩率是指压缩比乘以100%。
通过对比不同数据集上的压缩效果，我们可以评估哈夫曼编码在不同类型数据上的性能。
四、实验结果与分析1. 英文文章数据集对于一篇英文文章，经过哈夫曼编码压缩后，我们发现压缩比为0.6，即压缩后的数据只有原始数据的60%大小。
这说明哈夫曼编码在英文文本上具有较好的压缩效果。
原因在于英文文章中存在大量的重复字符，而哈夫曼编码能够利用字符的出现频率进行编码，从而减少数据的存储空间。
2. 中文文本数据集对于一段中文文本，我们发现哈夫曼编码的压缩效果不如在英文文章上的效果明显。
压缩比为0.8，即压缩后的数据只有原始数据的80%大小。
这是因为中文文本中的字符种类较多，并且出现频率相对均匀，导致哈夫曼编码的优势减弱。
哈夫曼编码实验报告
哈夫曼编码实验报告①问题描述：给定n个字符的权值数组w，根据哈夫曼编码与译码规则，实现一个哈夫曼编/译码系统（利用实验指导书上的27个字符的数据进行实验）。
②利用顺序表存储Huffman树，编码结果的存储方式采用书上的结构。
③Huffman树的构造约定如下：根的权值较小的子树作为左子树，当权值相等时，则先生成的子树是左子树；按照结点的生成次序选择权值较小的两棵子树构造Huffman树；从叶子结点到根结点逆向求出每个字符的Huffman编码，不采用递归方法；从根结点开始实现译码，要求被译码的字符数大于20个字符。
④采用文件方式存储n个权值和待翻译的二进制代码，其余数据均不采用文件存储。
序号字符权值双亲结点左孩子右孩子1 □186 0 0 02 A 64 0 0 03 B 13 0 0 04 C 22 0 0 05 D 32 0 0 06 E 103 0 0 07 F 21 0 0 08 G 15 0 0 09 H 47 0 0 010 I 57 0 0 011 J 1 0 0 012 K 5 0 0 013 L 32 0 0 014 M 20 0 0 015 N 57 0 0 016 O 63 0 0 017 P 15 0 0 018 Q 1 0 0 019 R 48 0 0 020 S 51 0 0 021 T 80 0 0 022 U 23 0 0 023 V 8 0 0 024 W 18 0 0 025 X 1 0 0 026 Y 16 0 0 027 Z 1 0 0 0实验过程与结果完整代码：（实验环境codeblock）关闭程序，重新开始，此时选择读取文件方式构建哈夫曼树，文件hafuman.txt中存储着各叶子节点权值，对应字符和待编译的二进制编码，读取文件截图如下，其他操作6.7.8及结果同上。
C语言-哈夫曼编码实验报告
福建工程学院课程设计课程：数据结构题目：哈夫曼编码和译码专业：信息管理信息系统班级： 1002班座号： 15号姓名：林左权2011年 6月 27日实验题目：哈夫曼编码和译码一、要解决的问题利用哈夫曼编码进行信息通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。
但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。
对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。
二、算法基本思想描述：根据给定的字符和其中每个字符的频度,构造哈夫馒树,并输出字符集中每个字符的哈夫曼编码.将给定的字符串根据其哈夫曼编码进行编码,并进行相应的译码.三、设计1. 数据结构的设计（1）哈夫曼树的表示设计哈夫曼树的结构体（htnode），其中包含权重、左右孩子、父母和要编码的字符。
用这个结构体（htnode）定义个哈夫曼数组（hfmt[]）。
迷宫定义如下：typedef struct{int weight;int lchild;int rchild;int parent;char key;}htnode;typedef htnode hfmt[MAXLEN];（2）对原始字符进行编码初始化哈夫曼树（inithfmt）。
从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树。
并显示出每个字符的编码。
1.void inithfmt(hfmt t)//对结构体进行初始化2.void inputweight(hfmt t)//输入函数3.void selectmin(hfmt t,int i,int *p1,int *p2)//选中两个权值最小的函数4.void creathfmt(hfmt t)//创建哈夫曼树的函数5.void phfmnode(hfmt t)//对字符进行初始编码（3）对用户输入的字符进行编码void encoding(hfmt t)//对用户输入的电文进行编码{char r[1000];//用来存储输入的字符串int i,j;printf("\n\n请输入需要编码的字符:");gets(r);printf("编码结果为:");for(j=0;r[j]!='\0';j++)for(i=0;i<n;i++)if(r[j]==t[i].key)hfmtpath(t,i,j);printf("\n");}（4）对用户输入的字符进行编码void decoding(hfmt t)//对用户输入的密文进行译码{char r[100];int i,j,len;j=2*n-2;//j初始从树的根节点开始printf("\n\n请输入需要译码的字符串:");gets(r);len=strlen(r);printf("译码的结果是:");for(i=0;i<len;i++){if(r[i]=='0'){j=t[j].lchild;if(t[j].lchild==-1){printf("%c",t[j].key);j=2*n-2;}}else if(r[i]=='1'){j=t[j].rchild;if(t[j].rchild==-1){printf("%c",t[j].key); j=2*n-2;}}}printf("\n\n");}四、源程序清单：#include <stdio.h>#include <stdlib.h>#include <string.h>#define MAXLEN 100typedef struct{int weight;int lchild;int rchild;int parent;char key;}htnode;typedef htnode hfmt[MAXLEN];int n;void inithfmt(hfmt t)//对结构体进行初始化{int i;printf("\n");printf("------------------------------------------------------------------\n"); printf("******************************输入区******************************\n");printf("\n请输入n=");scanf("%d",&n);getchar();for(i=0;i<2*n-1;i++)//对结构体进行初始化{t[i].weight=0;t[i].lchild=-1;t[i].rchild=-1;t[i].parent=-1;}printf("\n");}void inputweight(hfmt t)//输入函数{int w;//w表示权值int i;char k;//k表示获取的字符for(i=0;i<n;i++){printf("请输入第%d个字符:",i+1);scanf("%c",&k);getchar();t[i].key=k;printf("请输入第%d个字符的权值:",i+1);scanf("%d",&w);getchar();t[i].weight=w;printf("\n");}}void selectmin(hfmt t,int i,int *p1,int *p2)//选中两个权值最小的函数{long min1=999999;long min2=999999;int j;for(j=0;j<=i;j++)//选择最小权值字符的下标返回if(t[j].parent==-1)if(min1>t[j].weight){min1=t[j].weight;*p1=j;}for(j=0;j<=i;j++)//选择次小权值字符的下标还回if(t[j].parent==-1)if(min2>t[j].weight && j!=(*p1))//注意 j!=(*p1)) {min2=t[j].weight;*p2=j;}}void creathfmt(hfmt t)//创建哈夫曼树的函数{int i,p1,p2;inithfmt(t);inputweight(t);for(i=n;i<2*n-1;i++){selectmin(t,i-1,&p1,&p2);t[p1].parent=i;t[p2].parent=i;t[i].lchild=p1;t[i].rchild=p2;t[i].weight=t[p1].weight+t[p2].weight;}}void printhfmt(hfmt t)//打印哈夫曼树{int i;printf("------------------------------------------------------------------\n"); printf("**********************哈夫曼编数结构:*****************************\n");printf("\t\t权重\t父母\t左孩子\t右孩子\t字符\t");for(i=0;i<2*n-1;i++){printf("\n");printf("\t\t%d\t%d\t%d\t%d\t%c",t[i].weight,t[i].parent,t[i].lchild,t[i].rchild, t[i].key);}printf("\n------------------------------------------------------------------\n") ;printf("\n\n");}void hfmtpath(hfmt t,int i,int j)//编码的重要哈夫曼树路径递归算法{int a,b;a=i;b=j=t[i].parent;if(t[j].parent!=-1){i=j;hfmtpath(t,i,j);}if(t[b].lchild==a)printf("0");elseprintf("1");}void phfmnode(hfmt t)//对字符进行初始编码{int i,j,a;printf("\n------------------------------------------------------------------\n") ;printf("**************************哈夫曼编码******************************");for(i=0;i<n;i++){j=0;printf("\n");printf("\t\t%c\t",t[i].key,t[i].weight);hfmtpath(t,i,j);}printf("\n------------------------------------------------------------------\n") ;}void encoding(hfmt t)//对用户输入的电文进行编码{char r[1000];//用来存储输入的字符串int i,j;printf("\n\n请输入需要编码的字符:");gets(r);printf("编码结果为:");for(j=0;r[j]!='\0';j++)for(i=0;i<n;i++)if(r[j]==t[i].key)hfmtpath(t,i,j);printf("\n");}void decoding(hfmt t)//对用户输入的密文进行译码{char r[100];int i,j,len;j=2*n-2;//j初始从树的根节点开始printf("\n\n请输入需要译码的字符串:");gets(r);len=strlen(r);printf("译码的结果是:");for(i=0;i<len;i++){if(r[i]=='0'){j=t[j].lchild;if(t[j].lchild==-1){printf("%c",t[j].key);j=2*n-2;}}else if(r[i]=='1'){j=t[j].rchild;if(t[j].rchild==-1){printf("%c",t[j].key);j=2*n-2;}}}printf("\n\n");}int main(){int i,j;hfmt ht;char flag;printf(" |----------------------|\n");printf(" |信管1002--林左权--15号|\n");printf(" |**********************|\n");printf(" | 哈夫曼编码课程设计 |\n");printf(" |**********************|\n");printf(" |设计完成时间:2011/6/27|\n");printf(" |----------------------|\n");creathfmt(ht);printhfmt(ht);phfmnode(ht);printf("\n------------------------------------------------------------------\n") ;printf("***************************编码&&译码&&退出***********************");printf("\n【1】编码\t【2】\t译码\t【0】退出");printf("\n您的选择：");flag=getchar();getchar();while(flag!='0'){if(flag=='1')encoding(ht);else if(flag=='2')decoding(ht);elseprintf("您的输入有误，请重新输入。
哈弗曼编码数据结构实验报告
数据结构实验报告哈夫曼编码一、需求分析：哈夫曼编码可以进行求取最优二叉树，以及进行编码等实际问题，当利用哈夫曼树做前缀编码，有效的节约存储密码的时间。
二、概要设计：首先定义一个哈弗曼树结构体，哈夫曼编码数组之后，编写输入函数（包括存到文件的部分），哈弗曼构造函数（从文件中调用构造），求哈夫曼编码函数，输出函数（打印出哈夫曼编码）等。
三、详细设计：下为程序源代码：#include<stdio.h>#include<stdlib.h>#include<string.h>#include<ctype.h>#define Maxsize 100typedef struct{char data;double weight;int parent;int lchild;int rchild;}HTNode;HTNode ht[Maxsize];typedef struct{char cd[Maxsize];int start;}HCode;HCode hcd[Maxsize];void Initialization(char str[], double w[], int n);void getn(char str[], double w[], int *n);void writehfmTree(int n);void Encoding(int n);void ReadhfmTree(void);void Decoding(int n);void TreePrint(int i);void Menu(char *ch);int getnumber(char *ch, int repeat);void Initialization(char str[], double w[], int n) //构造哈弗曼树{int i,k,lnode,rnode;double min1, min2;for(i=0; i<n; i++){ht[i].data = str[i];ht[i].weight = w[i];}for(i=0; i<2*n-1; i++)ht[i].lchild = ht[i].parent = ht[i].rchild = -1;for(i=n; i<2*n-1; i++){min1=min2=32767;lnode=rnode=-1;for(k=0; k<=i-1; k++){if(ht[k].parent == -1){if(ht[k].weight < min1){min2 = min1;rnode = lnode;min1 = ht[k].weight;lnode = k;}else if(ht[k].weight < min2){min2 = ht[k].weight;rnode = k;}}}ht[i].weight = ht[lnode].weight + ht[rnode].weight;ht[i].lchild = lnode;ht[i].rchild = rnode;ht[lnode].parent = i;ht[rnode].parent = i;}writehfmTree(n);}void getn(char str[], double w[], int *n){int i;FILE *fp;if((fp=fopen("ToBeTran", "w"))==NULL){printf("Can not open the file\n");exit(0);}printf("请输入字符集：");gets(str);gets(str);*n = strlen(str);for(i=0; i<*n; i++){printf("请输入%d个权值：", i+1);scanf("%lf",&w[i]);}for(i=0; i<*n; i++)fprintf(fp, "%c", str[i]);fclose(fp);}void writehfmTree(int n) //把哈弗曼树存入hrmTree文件中{int i;FILE *fp;if((fp=fopen("hfmTree","w"))==NULL){printf("Can not open the file\n");exit(0);}for(i=0; i<n; i++){fputc(ht[i].data, fp);fprintf(fp, "%.2f", ht[i].weight);}fprintf(fp,"\n");printf("存在文件hfmTree中的哈弗曼树形式为：\n");for(i=0; i<n; i++){putchar(ht[i].data);putchar('-');printf("%.2f ", ht[i].weight);}printf("\n文件hfmTree写入成功！\n");fclose(fp);}void Encoding(int n) //哈弗曼编码,并存于文件CodeFile中{int i, j, k, f, c;HCode hc;FILE *fp, *fp1;char text[Maxsize];ReadhfmTree();if((fp1=fopen("ToBeTran","r"))==NULL){printf("Can not open the file\n");exit(0);}fgets(text, Maxsize, fp1);printf("要进行编码的字符串是：\n");puts(text);fclose(fp1);if((fp=fopen("CodeFile","w"))==NULL){printf("Can not open the file\n");exit(0);}for(i=0; i<n; i++){hc.start = n;c=i;f=ht[i].parent;while(f!=-1){if(ht[f].lchild == c)hc.cd[hc.start--]='0';elsehc.cd[hc.start--]='1';c=f;f=ht[f].parent;}hc.start++;hcd[i]=hc;}i=0;while(text[i]!='\0'){j=0;while(text[i]!=ht[j].data){j++;}for(k=hcd[j].start; k<=n; k++){fprintf(fp, "%c", hcd[j].cd[k]);}fputc(' ', fp);i++;}printf("编码结果如下：\n");i=0;while(text[i]!='\0'){j=0;while(text[i]!=ht[j].data){j++;}for(k=hcd[j].start; k<=n; k++){printf("%c", hcd[j].cd[k]);}printf(" ");i++;}printf("\n文件CodeFile写入成功！\n");fclose(fp);}void ReadhfmTree(void) //从内存中读入哈弗曼树，或从文件hfmTree文件中读取哈弗曼树{FILE *fp;char str[Maxsize];double w[Maxsize];int i=0, n;if(sizeof(ht)!=0)printf("内存中已存有哈弗曼树！\n");else{printf("内存中哈弗曼树不存在，从文件中读取数据重新构造哈弗曼树！\n");if((fp=fopen("hfmTree","r"))==NULL){printf("Can not open the file\n");exit(0);}do{fscanf(fp, "%c", &str[i]);fscanf(fp, "%lf", &w[i]);i++;}while(str[i]!='\n');n = i-2;Initialization(str, w, n);fclose(fp);}}void Decoding(int n)//从文件CodeFile中读入哈弗曼树编码，进行译码，将译码结果存入TextFile文件中{int i=0, j=0, k=0, l=0, num;char *text[Maxsize], str[Maxsize][Maxsize];FILE *fp, *fp1;if((fp=fopen("CodeFile","r"))==NULL){printf("Can not open the file “CodeFile”\n");exit(0);}if((fp1=fopen("TextFile","w"))==NULL){printf("Can not open the file “TextFile”\n");exit(0);}for(i=0; i<Maxsize; i++)text[i] = str[i];i=0;while(fscanf(fp, "%s", text[i])==1)i++;num = i;for(i=0; i<num; i++){l=0;j=0;k=hcd[l].start;while(1){if(hcd[l].cd[k]!=text[i][j]){l++;j=0;k=hcd[l].start;}else{j++;k++;}if(j==(signed)strlen(text[i]) && k==n+1)break;}fprintf(fp1, "%c", ht[l].data);}printf("译码结果如下：\n");for(i=0; i<num; i++){l=0;j=0;k=hcd[l].start;while(1){if(hcd[l].cd[k]!=text[i][j]){l++;j=0;k=hcd[l].start;}else{j++;k++;}if(j==(signed)strlen(text[i]) && k==n+1)break;}printf("%c", ht[l].data);}printf("\n文件TextFile写入成功！\n");fclose(fp);fclose(fp1);}void Print(void)//将文件CodeFile以紧凑个数显示在终端上，每行50个代码。
算法实验2-哈夫曼编码实验报告
算法实验2-哈夫曼编码实验报告
哈夫曼编码又称为霍夫曼编码，是1952年由克劳德·哈夫曼（Claude Elwood Shannon）提出的一种数据压缩和编码方法。
它可以从一个字符串中挑选出重复出现频率较高的字母等字符，将这些字母用比它们出现次数少的符号代替，从而达到减少数据存储空间的目的。
哈夫曼编码在文件压缩和网络传输中有着巨大的应用。
哈夫曼编码的原理基于信息论，利用熵的概念来实现数据压缩和编码。
熵是信息源发送信息的期望的信息量的度量，也就是说，发送的信息越多，熵越大。
所以，哈夫曼编码就是根据被发送信息的可能性来构造字符编码的，这样就能够优化发送的信息长度，从而实现数据压缩。
哈夫曼编码的基本步骤是：首先，根据待编码的字符统计其出现的频率，形成一棵二叉树；接着，给每个最底层的叶子节点分配编码，这里使用的是0和1来代替；最后，把最底层节点上的编码和字母相关联形成一个字符集。
哈夫曼编码得到的编码串中每个字符的编码长度都不一样，每个字符的编码长度取决于它出现的频率。
出现次数越多的字符编码得越短，这就使得哈夫曼编码能够获得比其他编码更短的编码长度，从而更好地完成数据压缩任务。
哈夫曼编码是实现数据压缩和编码的一种有效方法，它可以将数据压缩到最小可能的体积，同时使用起来非常简单。
它非常适用于实施网络传输的压缩处理，可以有效减少传输所需的时间，提高数据传输的效率。
哈夫曼实验报告(附代码)
哈弗曼编码/译码器一、程序的功能分析1．构造哈夫曼树及哈夫曼编码：从终端读入字符集大小n、n个字符以及n个对应的权值，建立哈夫曼树；利用已经建好的哈夫曼树求每个叶结点的哈夫曼编码，并保存。
2．编码：利用已构造的哈夫曼编码对“明文”文件中的正文进行编码，然后将结果存入“密文”文件中。
3．译码：将“密文”文件中的0、1代码序列进行译码。
(读文件)4．打印“密文”文件：将文件以紧凑格式显示在终端上，每行30个代码；同时，将此字符形式的编码文件保存。
5．打印哈夫曼树及哈夫曼编码：将已在内存中的哈夫曼树以凹入表形式显示在终端上，同时将每个字符的哈夫曼编码显示出来；并保存到文件。
二、基本要求分析1、输入输出的要求按提示内容从键盘输入命令，系统根据用户输入的需求在保证界面友好的前提下输出用户所需信息，并按要求保存文件，以便保存备份信息。
2、测试数据（1）．令叶子结点个数N为4，权值集合为{1,3,5,7}，字符集合为{A,B,C,D}，且字符集与权值集合一一对应。
（2）．令叶子结点个数N为7，权值集合为{12,6,8,18,3,20,2}，字符集合为{A,B,C,D,E,F,G}，且字符集与权值集合一一对应。
（3）．请自行选定一段英文文本，统计给出的字符集，实际统计字符的频度，建立哈夫曼树，构造哈夫曼编码，并实现其编码和译码。
三、概要设计1.主模块的流程及各子模块的主要功能主函数负责提供选项功能，循环调控整个系统。
创建模块实现接收字符、权值、构建哈夫曼树，并保存文件，此功能是后续功能的基础。
编码模块实现利用已编好的哈夫曼树对每个字符进行哈夫曼编码，即对每个字符译出其密文代码，并保存文件。
译码模块实现对用户输入的密文翻译成明文，即用户所需的字符串信息。
输出模块实现对已编好的哈夫曼树以凹入表的的形式输出。
2、模块之间的层次关系四、详细设计1.采用c语言定义的相关数据类型（1）结点的类型定义描述如下：#define N 叶子结点的个数typedef strcut{int weight; /*结点权值*/int parent;int lchild;int rchild;}HNodeType;HNodeType HNode[2*N-1];（2）编码的类型定义描述如下：#define MAXBIT 10typedef struct{int bit[MAXBIT];int start;}HCodeType;HCodeType HCode[N];2.各模块伪算法（1）主函数int main(){do:{界面友好设计;cout<<各个选项功能内容;cin>>ch;容错处理;switch(ch){case 1:.....}}while();return 0;}（2）系统初始化模块void create() //系统初始化{for(i=0;i<2*N-1;i++) //数组HNode初始化{};从键盘接收字符;for(i=0;i<N;i++){ cout<<"输入字符"<<endl;cin>>HNode[i].data;}接收权值;构造哈夫曼树;for(i=0;i<N-1;i++){ 找最小和次小两个权值；将找出的两棵子树合并为一棵子数；}将已建好的哈夫曼树存入文件hfmtree.txt中;调用哈夫曼编码子函数；}void HaffmanCode() //对哈夫曼树进行编码{从hfmtree.txt文件中读出哈夫曼树的信息存入内存HNodeType a[2*N-1]；求每个叶子结点的哈夫曼编码；for(i=0;i<N;i++){从叶节点回溯，回溯到根结点（parent==-1）;记录回溯路径；}打印出每个字符对应的密文；将密文信息存入文件codefile.dat中；}（3）编码模块void HfmanCode() //对用户输入的字符串进行编码{提示输入信息；接收用户输入的要编译的字符串；cin>>s;//从文件中读取哈夫曼编码信息infile.open ("F:\\codefile.dat",ios::in|ios::binary); //读文件for(i=0;i<N;i++) //将文件中的数据读出放在temp[i]内//从文件中读字节到指定的存储器区域。
数据结构实验哈夫曼树及哈夫曼编码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年。
哈夫曼编码译码实训报告
一、实训目的本次实训旨在通过实际操作，使学生掌握哈夫曼编码的基本原理和方法，熟悉哈夫曼树的构建过程，并能够熟练地进行哈夫曼编码和译码操作。
通过实训，提升学生对数据压缩技术的理解和应用能力。
二、实训内容1. 哈夫曼树构建- 收集给定字符串中每个字符的出现频率。
- 根据字符频率构建哈夫曼树，其中频率高的字符对应较大的权重。
- 使用优先队列（最小堆）实现哈夫曼树的构建。
2. 哈夫曼编码- 遍历哈夫曼树，为每个叶子节点分配唯一的编码，左分支为0，右分支为1。
- 根据分配的编码生成字符编码表。
3. 哈夫曼译码- 使用生成的编码表，将编码字符串转换回原始字符串。
三、实训步骤1. 数据准备- 选择一段英文或中文文本作为输入数据。
2. 构建哈夫曼树- 统计输入数据中每个字符的出现频率。
- 使用优先队列构建哈夫曼树。
3. 生成哈夫曼编码- 遍历哈夫曼树，为每个叶子节点分配编码。
- 生成字符编码表。
4. 编码数据- 使用哈夫曼编码表对输入数据进行编码。
5. 译码数据- 使用哈夫曼编码表对编码后的数据进行译码。
6. 结果分析- 比较编码前后数据的大小，分析哈夫曼编码的压缩效果。
四、实训结果1. 哈夫曼树构建- 成功构建了给定字符串的哈夫曼树。
2. 哈夫曼编码- 成功生成了每个字符的哈夫曼编码。
3. 哈夫曼译码- 成功将编码后的数据译码回原始字符串。
4. 压缩效果分析- 通过对比编码前后数据的大小，验证了哈夫曼编码的压缩效果。
五、实训总结1. 哈夫曼编码原理- 哈夫曼编码是一种基于字符频率的变长编码方法，能够有效降低数据传输的冗余度。
2. 哈夫曼树构建- 哈夫曼树的构建是哈夫曼编码的关键步骤，通过优先队列（最小堆）实现。
3. 哈夫曼编码与译码- 哈夫曼编码和译码过程相对简单，但需要正确处理编码表和字符编码。
4. 实训收获- 通过本次实训，掌握了哈夫曼编码的基本原理和方法，熟悉了哈夫曼树的构建过程，并能够熟练地进行哈夫曼编码和译码操作。
C语言-哈夫曼编码实验报告
福建工程学院课程设计课程：数据结构题目：哈夫曼编码和译码专业：信息管理信息系统班级： 1002班座号： 15号姓名：林左权2011年 6月 27日实验题目：哈夫曼编码和译码一、要解决的问题利用哈夫曼编码进行信息通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。
但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。
对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。
二、算法基本思想描述：根据给定的字符和其中每个字符的频度,构造哈夫馒树,并输出字符集中每个字符的哈夫曼编码.将给定的字符串根据其哈夫曼编码进行编码,并进行相应的译码.三、设计1. 数据结构的设计（1）哈夫曼树的表示设计哈夫曼树的结构体（htnode），其中包含权重、左右孩子、父母和要编码的字符。
用这个结构体（htnode）定义个哈夫曼数组（hfmt[]）。
迷宫定义如下：typedef struct{int weight;int lchild;int rchild;int parent;char key;}htnode;typedef htnode hfmt[MAXLEN];（2）对原始字符进行编码初始化哈夫曼树（inithfmt）。
从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树。
并显示出每个字符的编码。
inithfmt(hfmt t)ey)hfmtpath(t,i,j);printf("\n");}（4）对用户输入的字符进行编码void decoding(hfmt t)child;if(t[j].lchild==-1){printf("%c",t[j].key);j=2*n-2;}}else if(r[i]=='1'){j=t[j].rchild;if(t[j].rchild==-1){printf("%c",t[j].key); j=2*n-2;}}}printf("\n\n");}四、源程序清单：#include <>#include <>#include <>#define MAXLEN 100typedef struct{int weight;int lchild;int rchild;int parent;char key;}htnode;typedef htnode hfmt[MAXLEN];int n;void inithfmt(hfmt t)eight=0;t[i].lchild=-1;t[i].rchild=-1;t[i].parent=-1;}printf("\n");}void inputweight(hfmt t)ey=k;printf("请输入第%d个字符的权值:",i+1); scanf("%d",&w);getchar();t[i].weight=w;printf("\n");}}void selectmin(hfmt t,int i,int *p1,int *p2)arent==-1)if(min1>t[j].weight){min1=t[j].weight;*p1=j;}for(j=0;j<=i;j++)arent==-1)if(min2>t[j].weight && j!=(*p1))eight;*p2=j;}}void creathfmt(hfmt t)arent=i;t[p2].parent=i;t[i].lchild=p1;t[i].rchild=p2;t[i].weight=t[p1].weight+t[p2].weight;}}void printhfmt(hfmt t)eight,t[i].parent,t[i].lchild,t[i].rchild,t[i].key); }printf("\n------------------------------------------------------------------\n");printf("\n\n");}void hfmtpath(hfmt t,int i,int j)arent;if(t[j].parent!=-1){i=j;hfmtpath(t,i,j);}if(t[b].lchild==a)printf("0");elseprintf("1");}void phfmnode(hfmt t)ey,t[i].weight);hfmtpath(t,i,j);}printf("\n------------------------------------------------------------------\n") ;}void encoding(hfmt t)ey)hfmtpath(t,i,j);printf("\n");}void decoding(hfmt t)child;if(t[j].lchild==-1){printf("%c",t[j].key);j=2*n-2;}}else if(r[i]=='1'){j=t[j].rchild;if(t[j].rchild==-1){printf("%c",t[j].key);j=2*n-2;}}}printf("\n\n");}int main(){int i,j;hfmt ht;char flag;printf(" |----------------------|\n"); printf(" |信管1002--林左权--15号|\n");printf(" |**********************|\n");printf(" | 哈夫曼编码课程设计 |\n");printf(" |**********************|\n");printf(" |设计完成时间:2011/6/27|\n");printf(" |----------------------|\n");creathfmt(ht);printhfmt(ht);phfmnode(ht);printf("\n------------------------------------------------------------------\n") ;printf("***************************编码&&译码&&退出***********************");printf("\n【1】编码\t【2】\t译码\t【0】退出");printf("\n您的选择：");flag=getchar();getchar();while(flag!='0'){if(flag=='1')encoding(ht);else if(flag=='2')decoding(ht);elseprintf("您的输入有误，请重新输入。
哈夫曼实验报告总结
哈夫曼实验报告总结哈夫曼编码是一种用于数据压缩的有效算法，它能够将出现频率较高的字符用较短的编码表示，而将出现频率较低的字符用较长的编码表示，从而实现数据的压缩。
本次实验的目的是通过实现哈夫曼编码算法，深入理解哈夫曼编码的原理和应用，并通过实验证明其压缩效果。
在实验中，我们首先需要计算每个字符在给定文本中的出现频率。
通过统计文本中的字符频率，我们可以构建出一个字符频率表，其中每个字符和其对应的频率成对出现。
接下来，根据字符频率表，我们需要构建哈夫曼树。
哈夫曼树是一种特殊的二叉树，它的叶子节点对应于字符，而非叶子节点对应于字符的编码。
构建哈夫曼树的过程是通过将频率较小的字符不断相加作为新的频率节点，直到最终构建出完整的哈夫曼树。
构建哈夫曼树的过程是一个递归的过程，可以通过优先队列或最小堆来实现。
构建完哈夫曼树后，我们可以根据哈夫曼树为每个字符生成对应的编码。
在哈夫曼树中，从根节点到叶子节点的路径表示字符的编码，路径上的左-右方向分别表示0和1。
生成编码的过程是通过遍历哈夫曼树的路径，并记录经过的方向来实现的。
为了更高效地生成编码，可以使用哈希表或者数组来存储每个字符对应的编码。
实验中，我们将生成的哈夫曼编码应用于数据的压缩。
通过将文本中的每个字符替换为其对应的哈夫曼编码，并将生成的编码串连接起来，可以实现对数据的压缩。
压缩效果取决于字符的频率分布情况，频率更高的字符会得到较短的编码，而频率较低的字符会得到较长的编码。
在本次实验中，我们通过分别计算原始文本和压缩后文本的字节数，计算了压缩率。
压缩率的计算公式为：压缩率 = (1 - 压缩后字节数 / 原始字节数) * 100%。
通过实验数据的对比，我们可以发现，哈夫曼编码能够有效地减小数据的存储空间，实现较高的压缩率。
通过本次实验，我深入学习了哈夫曼编码的原理和实现方法。
哈夫曼编码是一种非常有效的数据压缩算法，广泛应用于各类数据压缩工具和通信传输中。
哈夫曼编码解码实验报告
哈夫曼编码解码实验1.实验要求掌握二叉树的相关概念掌握构造哈夫曼树，进行哈夫曼编码。
对编码内容通过哈夫曼树进行解码。
2.实验内容通过二叉树构造哈夫曼树，并用哈夫曼树对读取的txt文件进行哈夫曼编码。
编码完成后通过哈夫曼树进行解码。
#include<stdio.h>#include<string.h>#define MAX 100//定义哈夫曼树的存储结构typedef struct{char data;int weight;int parent;int lch;int rch;}HuffNode;//定义哈夫曼编码的存储结构typedef struct{char bit[MAX];int start;}HuffCode;HuffNode ht[2*MAX];HuffCode hcd[MAX];int Coun[127]={0};int n;char s1[200000];char text[5000];//构造哈夫曼树void HuffmanTree(){int i,j,k,left,right,min1,min2;//printf("输入叶子的节点数：");//scanf("%d",&n);printf("字符数量=%d\n",n);for(i=1;i<=2*n-1;i++){ht[i].parent=ht[i].lch=ht[i].rch=0;}j=0;for(i=1;i<=n;i++){/*getchar();printf("输入第%d个叶子节点的值：",i);scanf("%c",&ht[i].data);printf("输入该节点的权值：");scanf("%d",&ht[i].weight);*/for(;j<127;j++){if(Coun[j]!=0){ht[i].data=j;//printf("%c",ht[i].data);ht[i].weight=Coun[j];//printf("%d",ht[i].weight);break;}}j++;}printf("\n");for(i=1;i<=n;i++){printf("%c",ht[i].data);}printf("\n");for(i=n+1;i<=2*n-1;i++){//在前n个结点中选取权值最小的两个结点构成一颗二叉树min1=min2=10000;//为min1和min2设置一个比所有权值都大的值left=right=0;for(k=1;k<=i-1;k++){if(ht[k].parent==0)//若是根结点//令min1和min2为最小的两个权值，left和right 为权值最小的两个结点位置if(ht[k].weight<min1){min2=min1;right=left;min1=ht[k].weight;left=k;}else if (ht[k].weight<min2){min2=ht[k].weight;right=k;}}ht[left].parent=i;ht[right].parent=i;ht[i].weight=ht[left].weight+ht[right].weight;ht[i].lch=left;ht[i].rch =right;}}//构造哈夫曼编码void HuffmanCode(){int i,c,k,f;HuffCode cd;for(i=1;i<=n;i++){cd.start=n;c=i;f=ht[i].parent;while(f!=0){if(ht[f].lch==c)cd.bit[cd.start]='0';elsecd.bit[cd.start]='1';cd.start--;c=f;f=ht[f].parent;}hcd[i]=cd;}printf("输出哈夫曼编码：\n");for(i=1;i<=n;i++){printf("%c:",ht[i].data);for(k=hcd[i].start+1;k<=n;k++)printf("%c",hcd[i].bit[k]);printf("\n");}}//对字母进行编码void Code()//将字符与相应的哈夫曼编码进行匹配，输出编码结果{int i=0,j,k,h=0;while(text[i]!='\0'){for(j=1;j<=n;j++){if(text[i]==ht[j].data){for(k=hcd[j].start+1;k<=n;k++){s1[h]=hcd[j].bit[k];h++;}break;}}i++;}//printf("编码\n");//puts(s1);//printf("\n");}//解码void HuffmanDecode(){printf("解码\n");int len,i,f;char C;//char S[MAXCODE];//scanf("%s",S);//使用gets()直接跳过len=strlen(s1);printf("s1:%d\n",len);f=2*n-1;for(i=0;i<len;i++){if(s1[i]=='0'){f=ht[f].lch;if(ht[f].lch==0&&ht[f].rch==0){C=ht[f].data;printf("%c",C);f=2*n-1;}}else if(s1[i]=='1'){f=ht[f].rch;if(ht[f].lch==0&&ht[f].rch==0){C=ht[f].data;printf("%c",C);f=2*n-1;}}}printf("\n");}//统计字母个数及其权值void Count(){int i,j,m;n=0;i=0;//printf("请仅输入小写字母\n");//例程本省存在一个BUG，只输入一个字母不能进行编码（并未解决）//scanf("%s",s);while(text[i]!='\0')//使用ASCII码表进行统计{m=text[i];//printf("%d\n",m);Coun[m]++;i++;}for(j=0;j<127;j++){if(Coun[j]!=0)n++;}}//mark Codevoid main(){int l=0;FILE *fp;fp=fopen("text.txt","r");if(fp==NULL){printf("文件打开失败\n");while(1);}while(!feof(fp)){text[l] = fgetc(fp);l++;}printf("输入文本\n");printf("%s\n",text);fclose(fp);Count();HuffmanTree();HuffmanCode();Code();HuffmanDecode();}文本文件文本输入进行哈夫曼编码对文本进行编码输出解码结果3.实验总结通过本次实验，对二叉树的应用有了相应的了解，掌握了如何构造哈夫曼编码，如何对编码结果进行解码。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
福建工程学院课程设计课程：数据结构题目：哈夫曼编码和译码专业：信息管理信息系统班级：1002班座号：15号姓名：林左权2011年6月27日实验题目：哈夫曼编码和译码一、要解决的问题利用哈夫曼编码进行信息通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。
但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。
对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。
二、算法基本思想描述：根据给定的字符和其中每个字符的频度,构造哈夫馒树,并输出字符集中每个字符的哈夫曼编码.将给定的字符串根据其哈夫曼编码进行编码,并进行相应的译码.三、设计1. 数据结构的设计（1）哈夫曼树的表示设计哈夫曼树的结构体（htnode），其中包含权重、左右孩子、父母和要编码的字符。
用这个结构体（htnode）定义个哈夫曼数组（hfmt[]）。
迷宫定义如下：typedef struct{int weight;int lchild;int rchild;int parent;char key;}htnode;typedef htnode hfmt[MAXLEN];（2）对原始字符进行编码初始化哈夫曼树（inithfmt）。
从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树。
并显示出每个字符的编码。
1.void inithfmt(hfmt t)//对结构体进行初始化2.void inputweight(hfmt t)//输入函数3.void selectmin(hfmt t,int i,int *p1,int *p2)//选中两个权值最小的函数4.void creathfmt(hfmt t)//创建哈夫曼树的函数（3）对用户输入的字符进行编码void encoding(hfmt t)//对用户输入的电文进行编码{char r[1000];//用来存储输入的字符串int i,j;printf("\n\n请输入需要编码的字符:");gets(r);printf("编码结果为:");for(j=0;r[j]!='\0';j++)for(i=0;i<n;i++)if(r[j]==t[i].key)hfmtpath(t,i,j);printf("\n");}（4）对用户输入的字符进行编码void decoding(hfmt t)//对用户输入的密文进行译码{char r[100];int i,j,len;j=2*n-2;//j初始从树的根节点开始printf("\n\n请输入需要译码的字符串:");gets(r);len=strlen(r);printf("译码的结果是:");for(i=0;i<len;i++){if(r[i]=='0'){j=t[j].lchild;if(t[j].lchild==-1){printf("%c",t[j].key);j=2*n-2;}else if(r[i]=='1'){j=t[j].rchild;if(t[j].rchild==-1){printf("%c",t[j].key);j=2*n-2;}}}printf("\n\n");}四、源程序清单：#include <stdio.h>#include <stdlib.h>#include <string.h>#define MAXLEN 100typedef struct{int weight;int lchild;int rchild;int parent;char key;}htnode;typedef htnode hfmt[MAXLEN];int n;void inithfmt(hfmt t)//对结构体进行初始化{printf("\n");printf("------------------------------------------------------------------\n");printf("******************************输入区******************************\n");printf("\n请输入n=");scanf("%d",&n);getchar();for(i=0;i<2*n-1;i++)//对结构体进行初始化{t[i].weight=0;t[i].lchild=-1;t[i].rchild=-1;t[i].parent=-1;}printf("\n");}void inputweight(hfmt t)//输入函数{int w;//w表示权值int i;char k;//k表示获取的字符for(i=0;i<n;i++){printf("请输入第%d个字符:",i+1);scanf("%c",&k);getchar();t[i].key=k;printf("请输入第%d个字符的权值:",i+1);scanf("%d",&w);getchar();t[i].weight=w;printf("\n");}}void selectmin(hfmt t,int i,int *p1,int *p2)//选中两个权值最小的函数{long min1=999999;long min2=999999;int j;for(j=0;j<=i;j++)//选择最小权值字符的下标返回if(t[j].parent==-1)if(min1>t[j].weight){min1=t[j].weight;*p1=j;}for(j=0;j<=i;j++)//选择次小权值字符的下标还回if(t[j].parent==-1)if(min2>t[j].weight && j!=(*p1))//注意j!=(*p1)){min2=t[j].weight;*p2=j;}}void creathfmt(hfmt t)//创建哈夫曼树的函数{int i,p1,p2;inithfmt(t);inputweight(t);for(i=n;i<2*n-1;i++){selectmin(t,i-1,&p1,&p2);t[p1].parent=i;t[p2].parent=i;t[i].lchild=p1;t[i].weight=t[p1].weight+t[p2].weight;}}void printhfmt(hfmt t)//打印哈夫曼树{int i;printf("------------------------------------------------------------------\n");printf("**********************哈夫曼编数结构:*****************************\n");printf("\t\t权重\t父母\t左孩子\t右孩子\t字符\t");for(i=0;i<2*n-1;i++){printf("\n");printf("\t\t%d\t%d\t%d\t%d\t%c",t[i].weight,t[i].parent,t[i].lchild,t[i].rchild,t[i].key);}printf("\n------------------------------------------------------------------\n");printf("\n\n");}void hfmtpath(hfmt t,int i,int j)//编码的重要哈夫曼树路径递归算法{int a,b;a=i;b=j=t[i].parent;if(t[j].parent!=-1){i=j;hfmtpath(t,i,j);}if(t[b].lchild==a)printf("0");printf("1");}void phfmnode(hfmt t)//对字符进行初始编码{int i,j,a;printf("\n------------------------------------------------------------------\n");printf("**************************哈夫曼编码******************************");for(i=0;i<n;i++){j=0;printf("\n");printf("\t\t%c\t",t[i].key,t[i].weight);hfmtpath(t,i,j);}printf("\n------------------------------------------------------------------\n"); }void encoding(hfmt t)//对用户输入的电文进行编码{char r[1000];//用来存储输入的字符串int i,j;printf("\n\n请输入需要编码的字符:");gets(r);printf("编码结果为:");for(j=0;r[j]!='\0';j++)for(i=0;i<n;i++)if(r[j]==t[i].key)hfmtpath(t,i,j);printf("\n");}void decoding(hfmt t)//对用户输入的密文进行译码{char r[100];int i,j,len;j=2*n-2;//j初始从树的根节点开始printf("\n\n请输入需要译码的字符串:");gets(r);len=strlen(r);printf("译码的结果是:");for(i=0;i<len;i++){if(r[i]=='0'){j=t[j].lchild;if(t[j].lchild==-1){printf("%c",t[j].key);j=2*n-2;}}else if(r[i]=='1'){j=t[j].rchild;if(t[j].rchild==-1){printf("%c",t[j].key);j=2*n-2;}}}printf("\n\n");}int main()int i,j;hfmt ht;char flag;printf(" |----------------------|\n");printf(" |信管1002--林左权--15号|\n");printf(" |**********************|\n");printf(" | 哈夫曼编码课程设计|\n");printf(" |**********************|\n");printf(" |设计完成时间:2011/6/27|\n");printf(" |----------------------|\n");creathfmt(ht);printhfmt(ht);phfmnode(ht);printf("\n------------------------------------------------------------------\n");printf("***************************编码&&译码&&退出***********************");printf("\n【1】编码\t【2】\t译码\t【0】退出");printf("\n您的选择：");flag=getchar();getchar();while(flag!='0'){if(flag=='1')encoding(ht);else if(flag=='2')decoding(ht);elseprintf("您的输入有误，请重新输入。