数据结构课程设计哈夫曼编码和译码报告
数据结构哈夫曼树编码及译码的实现实验报告
实验:哈夫曼树编码及译码的实现一.实验题目给定字符集的HUFFMANN编码与解码,这里的字符集及其字符频数自己定义,要求输出个字符集的哈夫曼编码及给定的字符串的哈夫曼码及译码结果。
二.实验原理首先规定构建哈夫曼树,然后进行哈夫曼树的编码,接着设计函数进行字符串的编码过程,最后进行哈夫曼编码的译码。
首先定义一个结构体,这个结构体定义时尽可能的大,用来存放左右的变量,再定义一个地址空间,用于存放数组,数组中每个元素为之前定义的结构体。
输入n个字符及其权值。
构建哈夫曼树:在上述存储结构上实现的哈夫曼算法可大致描述为:1.首先将地址空间初始化,将ht[0…n-1]中所有的结点里的指针都设置为空,并且将权值设置为0.2.输入:读入n个叶子的权值存于向量的前n个分量中。
它们是初始森林中n个孤立的根结点上的权值。
3.合并:对森林中的树共进行n-1次合并,所产生的新结点依次放入向量ht的第i个分量中。
每次合并分两步:①在当前森林ht[0…i-1]的所有结点中,选取权最小和次小的两个根结点[s1]和 [s2]作为合并对象,这里0≤s1,s2≤i-1。
②将根为ht[s1]和ht[s2]的两棵树作为左右子树合并为一棵新的树,新树的根是新结点ht[i]。
具体操作:将ht[s1]和ht[s2]的parent置为i,将ht[i]的lchild和rchild分别置为s1和s2 .新结点ht[i]的权值置为ht[s1]和ht[s2]的权值之和。
4.哈夫曼的编码:约定左子为0,右子为1,则可以从根结点到叶子结点的路径上的字符组成的字符串作为该叶子结点的编码。
当用户输入字母时。
就在已经找好编码的编码结构体中去查找该字母。
查到该字母就打印所存的哈夫曼编码。
接着就是完成用户输入0、1代码时把代码转成字母的功能。
这是从树的头结点向下查找,如果当前用户输入的0、1串中是0则就走向该结点的左子。
如果是1这就走向该结点的右结点,重复上面步骤。
数据结构课程设计总结报告 哈夫曼编码译码
《数据结构》课程设计实验报告题目哈夫曼编码/译码器学院数理与信息学院专业计算机科学与技术班级计科132学生姓名刘海澍 5周弘杰8徐铭瑶 3指导教师编写日期数据结构课程设计目录1 问题描述.................................................................错误!未定义书签。
2 问题分析.................................................................错误!未定义书签。
3 算法设计 (2)3.1抽象数据类型定义 (2)3.2模块划分 (3)4 详细设计 (4)4.1数据类型的定义 (4)4.2主要模块的算法描述 (4)4.3 流程图 (6)5 测试分析 (9)6 课程设计总结 (10)7 成员分工 (10)参考文献 (11)附录(源程序清单) (12)1.问题描述设计一个利用哈夫曼算法的编码和译码系统,重复地显示并处理以下项目,直到选择退出为止。
1) 初始化:键盘输入字符集大小n、n个字符和n个权值,建立哈夫曼树;2) 编码:利用建好的哈夫曼树生成哈夫曼编码;3) 输出编码;4)显示哈夫曼树;5)界面设计的优化;6) 设字符集及频度如下表:字符空格 A B C D E F频度4 9 23 2 17 15字符G H I J K频度1 2 3 3 42.问题分析(1)定义一个变量名为HTNode的结构体,用该结构体中的char data、int weight、int parent、int lchild、int rchild分别表示哈夫曼树中每个结点的权值、权重、双亲结点、左孩子、右孩子,再定义一个HTNode类型的数组ht[60]存放哈夫曼树;另外定义一个变量名为HCode的结构体,采用HCode类型变量的cd[start]~cd[n]存放当前结点的哈夫曼编码、最后定义一个HCode类型的数组hcd[30]的数组用于存放当前叶子结点ht[i]的哈夫曼编码。
数据结构课程设计哈夫曼编码实验
数据结构设计性实验Huffman编码与译码学号姓名班级设计性实验—Huffman 编码与译码一.实验目的:在掌握相关基础知识的基础上,学会自己设计实验算法,熟练掌握Huffman 树的建立方法,Huffman 编码的方法,进而设计出Huffman 译码算法,并编程实现。
二.实验要求:在6学时以内,制作出能够实现基于26个英文字母的任意字符串的编译码。
写出技术工作报告并附源程序。
三.实验内容及任务:1.设字符集为26个英文字母,其出现频度如下表所示。
2.建Huffman 树; 3.利用所建Huffman 树对任一字符串文件进行编码——即设计一个Huffman 编码器;4.对任一字符串文件的编码进行译码——即设计一个Huffman 译码器。
实现步骤:1.数据存储结构设计; 2.操作模块设计; 3.建树算法设计; 4.编码器设计;5. 译码器设计;51 48 1 15 63 57 20 32 5 1频度z y x w v u t 字符11611882380频度p 21 f q15 g r 47 h s o n m l k j 字符 57 103 32 22 13 64 186 频度 i e d c b a 空格 字符四.分析以及算法描述1.分析问题1)首先学习二叉树的知识,了解二叉树的路径、权数以及带权路径长度计算。
2)认识霍夫曼树,了解霍夫曼树的定义,构造霍夫曼树构造算法①又给定的n个权值{w1,w2,w3,……,w n}构造根节点的二叉树,从而得到一个二叉树森林F={T1,T2,T3,……T n}。
②在二叉树森里选取根节点全职最小和此最小的两棵二叉树作为左右节点构造新的二叉树,此时新的二叉树的根节点权值为左右子树权值之和。
③在二叉树森林中删除作为新二叉树的根节点左右子树的两棵二叉树,将新的二叉树加入到二叉树森林F中。
④重复②和③,当二叉树森林F只剩下一棵二叉树时,这棵二叉树是所构造的霍夫曼树。
3)练习通过普通树来构造霍夫曼树。
数据结构 哈夫曼树编码译码 课程设计 实验报告
数据结构课程设计设计题目:哈夫曼树编码译码目录第一章需求分析 (1)第二章设计要求 (1)第三章概要设计 (2)(1)其主要流程图如图1-1所示。
(3)(2)设计包含的几个方面 (4)第四章详细设计 (4)(1)①哈夫曼树的存储结构描述为: (4)(2)哈弗曼编码 (5)(3)哈弗曼译码 (7)(4)主函数 (8)(5)显示部分源程序: (8)第五章调试结果 (10)第六章心得体会 (12)第七章参考文献 (12)附录: (12)在当今信息爆炸时代,如何采用有效的数据压缩技术节省数据文件的存储空间和计算机网络的传送时间已越来越引起人们的重视,哈夫曼编码正是一种应用广泛且非常有效的数据压缩技术。
哈夫曼编码是一种编码方式,以哈夫曼树—即最优二叉树,带权路径长度最小的二叉树,经常应用于数据压缩。
哈弗曼编码使用一张特殊的编码表将源字符(例如某文件中的一个符号)进行编码。
这张编码表的特殊之处在于,它是根据每一个源字符出现的估算概率而建立起来的(出现概率高的字符使用较短的编码,反之出现概率低的则使用较长的编码,这便使编码之后的字符串的平均期望长度降低,从而达到无损压缩数据的目的)。
哈夫曼编码的应用很广泛,利用哈夫曼树求得的用于通信的二进制编码称为哈夫曼编码。
树中从根到每个叶子都有一条路径,对路径上的各分支约定:指向左子树的分支表示“0”码,指向右子树的分支表示“1”码,取每条路径上的“0”或“1”的序列作为和各个叶子对应的字符的编码,这就是哈夫曼编码。
哈弗曼译码输入字符串可以把它编译成二进制代码,输入二进制代码时可以编译成字符串。
第二章设计要求对输入的一串电文字符实现哈夫曼编码,再对哈夫曼编码生成的代码串进行译码,输出电文字符串。
通常我们把数据压缩的过程称为编码,解压缩的过程称为解码。
电报通信是传递文字的二进制码形式的字符串。
但在信息传递时,总希望总长度能尽可能短,即采用最短码。
假设每种字符在电文中出现的次数为Wi,编码长度为Li,电文中有n种字符,则电文编码总长度为∑WiLi。
哈夫曼编译码器课程设计报告(完整版)
XXX学院本科数据结构课程设计总结报告设计题目:实验一、哈夫曼编/译码器学生姓名:XXX系别:XXX专业:XXX班级:XXX学号:XXX指导教师:XXX XXX2012年6 月21日xxx学院课程设计任务书题目一、赫夫曼编译码器专业、班级xxx学号xxx 姓名xxx主要内容、基本要求、主要参考资料等:1. 主要内容利用哈夫曼编码进行信息通信可大大提高信道利用率,缩短信息传输时间,降低传输成本。
要求在发送端通过一个编码系统对待传数据预先编码;在接收端将传来的数据进行译码(复原)。
对于双工信道(既可以双向传输信息的信道),每端都需要一个完整的编/译码系统。
试为这样的信息收发站写一个哈夫曼的编/译码系统。
2. 基本要求系统应具有以下功能:(1)C:编码(Coding)。
对文件tobetrans中的正文进行编码,然后将结果存入文件codefile中,将以此建好的哈夫曼树存入文件HuffmanTree中(2)D:解码(Decoding)。
利用已建好的哈夫曼树将文件codefile中的代码进行译码,结果存入textfile中。
(3)P:打印代码文件(Print)。
将文件codefile以紧凑格式显示在终端上,每行50个代码。
同时将此字符形式的编码文件写入文件codeprint中。
(4)T:打印哈夫曼树(Tree Printing)。
将已在内存中的哈夫曼树以直观的方式(树或凹入表形式)显示在终端上,同时将此字符形式的哈夫曼树写入文件treeprint中。
3. 参考资料:数据结构(C语言版)严蔚敏、吴伟民编著;数据结构标准教程胡超、闫宝玉编著完成期限:2012年6月21 日指导教师签名:课程负责人签名:2012年 6月 21 日一、设计题目(任选其一)实验一、哈夫曼编/译码器二、实验目的1巩固和加深对数据结构的理解,提高综合运用本课程所学知识的能力;2 深化对算法课程中基本概念、理论和方法的理解;3 巩固构造赫夫曼树的算法;4 设计试验用程序实验赫夫曼树的构造。
数据结构哈夫曼树编码译码实验报告.doc
数据结构哈夫曼树编码译码实验报告.【详细设计】具体代码实现如下://HaffmanTree.h#include#include#includestruct HuffmanNode //哈夫曼树的一个结点{ int weight; int parent; int lchild,rchild; };class HuffmanTree //哈夫曼树{private: HuffmanNode *Node; //Node[]存放哈夫曼树char *Info; //Info[]存放源文用到的字符——源码,如'a','b','c','d','e',此内容可以放入结点中,不单独设数组存放int LeafNum; //哈夫曼树的叶子个数,也是源码个数public: HuffmanTree(); ~HuffmanTree(); void CreateHuffmanTree(); /*在内存中建立哈夫曼树,存放在Node[]中。
让用户从两种建立哈夫曼树的方法中选择:1.从键盘读入源码字符集个数,每个字符,和每个字符的权重,建立哈夫曼树,并将哈夫曼树写入文件hfmTree中。
2.从文件hfmTree中读入哈夫曼树信息,建立哈夫曼树*/ void CreateHuffmanTreeFromKeyboard(); void CreateHuffmanTreeFromFile(); void Encoder(); /*使用建立好的哈夫曼树(如果不在内存,则从文件hfmTree中读入并建立内存里的哈夫曼树),对文件ToBeTran中的正文进行编码,并将码文写入文件CodeFile中。
ToBeTran的内容可以用记事本等程序编辑产生。
*/ void Decoder(); /*待译码的码文存放在文件CodeFile中,使用建立好的哈夫曼树(如果不在内存,则从文件hfmTree中读入并建立内存里的哈夫曼树)将码文译码,得到的源文写入文件TextFile中,并同时输出到屏幕上。
数据结构完整的课程设计报告-哈夫曼编译码器
课程设计任务书课程名称数据结构课程设计课题赫夫曼编译码器专业班级网络工程***学生姓名***学号**指导老师审批任务书下达日期:2011 年6 月26 日任务完成日期:2011 年7 月15 日一、设计内容1)问题描述对输入的一串电文字符实现赫夫曼编码,再对赫夫曼编码生成的代码串进行译码,输出电文字符串。
2)基本要求a.初始化,键盘输入字符集大小n,n个字符和n个权植,建立哈夫曼树。
b.编码,利用建好的huffman树生成huffman编码;c.输出编码;d.译码功能;二.设计要求:课程设计报告1)需求分析a.程序的功能。
1.初始化,键盘输入字符集大小n,n个字符和n个权植,建立哈夫曼树。
2.编码,利用建好的huffman树生成huffman编码;3.输出编码;4.译码功能;b.输入输出的要求。
2)概要设计a.程序由哪些模块组成以及模块之间的层次结构、各模块的调用关系;每个模块的功能。
i.void main()ii.void tohuffmancode(int n)//编码部分iii.void decode(char ch[],huftree tree[],int n)//译码iv.void huffman(huftree tree[],int *w,int n) //生成huffman树v.void select(huftree tree[],int k) //找寻parent为0,权最小的两个节点vi.void huffmancode(huftree tree[],char code[],int n)//输出huffman编码其流程图如下:主函数main 调用其他函数:tohuffmancode(int n)decode(char ch[],huftree tree[],int n)huffman(huftree tree[],int *w,int n)select(huftree tree[],int k)huffmancode(huftree tree[],char code[],int n) 其主流程图如下:(3)主要模块程序流程图下面介绍三个主要的程序模块流程图:①函数流程图:流程图注释:该图比较简单,主要是调用各个函数模块,首先代开已经存在的文件,然后统计总的字符数以及出现的各个字符和频率。
哈夫曼编_译码器数据结构课程设计报告
摘要哈夫曼编码是根据字符的使用率的高低对字符进行不等长的编码,从而使使用率高的字符占用较少的空间,从而在传输的过程中大大提高了数据的空间传输效率。
本设计采用二叉链表的存储结构,建立哈夫曼树;用递归调用的方式对哈夫曼树的节点进行编码,生成与字符对应的哈夫曼编码。
本设计完全采用C++语言进行编程,并在XCode 6编译器上调试运行通过。
本程序使用中文界面,并有相应的提示信息,便于操作和程序运行。
关键词:哈夫曼树;哈夫曼编码;递归调用;二叉链表AbstractHuffman coding is based on the level of usage of characters ranging from long coding, so that high usage rate of the characters occupy less storage space , in the course of transmission has greatly enhanced the efficiency of data transmission space. This design build the Huffman tree by using Binary Tree storage structure, encoded Huffman tree nodes by recursive calling, and the characters generate the corresponding Huffman coding. The procedure completely write with C++ language and has Chinese explanatory note. What’s more, i t was debugged in XCode 6 debugger and run well. The whole procedure, with Chinese interface and the corresponding tips ,is convenient to run and easy to be operated.Keywords: Huffman Tree; Huffman code; Recursive call; Binary List目录摘要 0ABSTRACT (1)一、问题描述(内容格式参考下面的描述,以下类似) (3)1、问题描述: (3)2、基本要求: (3)二、需求分析 (3)2.1设计目标 (3)2.2设计思想 (3)三、概要设计 (4)3.1程序结构 (4)3.2初始化算法: (4)3.3编码算法: (4)3.4译码算法: (4)四、数据结构设计 (4)五、算法设计 (5)1、算法分析(必须要用语言进行描述) (5)2、算法实现 (6)六、程序测试与实现 (11)1、主程序 (11)2、测试数据 (12)3、测试结果 (14)生成哈夫曼树运行结果图: (14)哈夫曼编码运行结果图: (15)编码函数运行结果图: (15)译码函数运行结果图: (15)平均编码长度函数运行结果图: (15)七、调试分析 (15)程序调试的步骤: (15)调试体会: (16)八、遇到的问题及解决办法 (16)九、心得体会 (16)一、问题描述(内容格式参考下面的描述,以下类似)1、问题描述:利用哈夫曼编码进行信息通信可以大大提高信道利用率,缩短信息传输时间,降低传输成本。
数据结构课程设计报告--哈夫曼编码译码--陈荣鑫
《数据结构》课程设计报告单【题目】哈夫曼编码/译码的设计与实现【目的】通过布置具有一定难度的实际程序设计项目,进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法,以及它们在程序中的使用方法;掌握分析问题,求解问题的方法并提高学生设计编程实现的能力。
【要求】基本要求:1.要求利用C\C++语言来完成系统的设计;2.突出C语言的函数特征(以多个函数实现每一个子功能)或者C++语言面向对象的编程思想;3.画出功能模块图;4.进行简单界面设计,能够实现友好的交互;5.具有清晰的程序流程图和数据结构的详细定义;6.熟练掌握C语言或者C++语言的各种操作。
创新要求:在基本要求达到后,可进行创新设计,如系统用户功能控制,改进算法的实现,实现友好的人机交互等等【主要内容及实现的功能】给定26个城市间的距离网(p187),用Dijkstra方法求最短路径;广度优先搜索方法显示城市间最少中转路径;用Prim算法建立最小生成树,并计算得到的最小生成树的代价。
【原始数据及资料】【主要参考资料】【课程设计报告单】1、系统设计分析本系统有两大模块组成:1)哈夫曼树和哈夫曼编码的存储:由于哈夫曼树中没有度为1的结点,则一颗有n个叶子结点的哈夫曼树共有2n-1个结点,可以储存在一个大小为2n-1的一维数组中;由于在构成哈夫曼树之后,为求编码需从叶子结点出发走一条从叶子结点到根的路径,而译码需要走一条从根到叶子结点的路径,则对每个结点而言,既需知双亲的信息,又需要知道孩子结点的信息。
2)二叉树的遍历:由于各字符的编码长度不等,所以按实际长度动态分配空间,从实际情况出发,持此遍历采用无栈非递归遍历哈夫曼树,求哈夫曼编码2、算法描述(实现思路)1)构造哈夫曼树算法描述:void HuffmanCoding(HuffmanTree &HT, HuffmanCode &HC, int *w, int n) { // w存放n个字符的权值(均>0),构造哈夫曼树HT,// 并求出n个字符的哈夫曼编码HCint i, j, m, s1, s2, start;char *cd;unsigned int c, f;if (n<=1) return;m = 2 * n - 1;HT = (HuffmanTree)malloc((m+1) * sizeof(HTNode)); // 0号单元未用for (i=1; i<=n; i++) { //初始化HT[i].weight=w[i-1];HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}for (i=n+1; i<=m; i++) { //初始化HT[i].weight=0;HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}printf("\n哈夫曼树的构造过程如下所示:\n");printf("HT初态:\n 结点 weight parent lchild rchild");for (i=1; i<=m; i++)printf("\n%4d%8d%8d%8d%8d",i,HT[i].weight,HT[i].parent,HT[i].lchild, HT[i].rchild);printf(" 按任意键,继续 ...");getch();for (i=n+1; i<=m; i++) { // 建哈夫曼树// 在HT[1..i-1]中选择parent为0且weight最小的两个结点,// 其序号分别为s1和s2。
数据结构哈夫曼树编码译码实验报告
【具体设计】之杨若古兰创作具体代码实现如下:#include<iostream>#include<fstream>#include<string>struct HuffmanNode //哈夫曼树的一个结点{int weight;int parent;int lchild,rchild;};class HuffmanTree //哈夫曼树{private:HuffmanNode *Node; //Node[]存放哈夫曼树char *Info; //Info[]存放源文用到的字符——源码,如'a','b','c','d','e',此内容可以放入结点中,不单独设数组存放 int LeafNum; //哈夫曼树的叶子个数,也是源码个数public:HuffmanTree();~HuffmanTree();void CreateHuffmanTree(); /*在内存中建立哈夫曼树,存放在Node[]中. 让用户从两种建立哈夫曼树的方法当选择:1.从键盘读入源码字符集个数,每个字符,和每个字符的权重,建立哈夫曼树,并将哈夫曼树写入文件hfmTree中.2.从文件hfmTree中读入哈夫曼树信息,建立哈夫曼树*/void CreateHuffmanTreeFromKeyboard();void CreateHuffmanTreeFromFile();void Encoder(); /*使用建立好的哈夫曼树(如果不在内存,则从文件hfmTree中读入并建立内存里的哈夫曼树),对文件ToBeTran中的注释进行编码,并将码文写入文件CodeFile中.ToBeTran的内容可以用记事本等程序编辑发生.*/void Decoder(); /*待译码的码文存放在文件CodeFile中,使用建立好的哈夫曼树(如果不在内存,则从文件hfmTree中读入并建立内存里的哈夫曼树)将码文译码,得到的源文写入文件TextFile中,并同时输出到屏幕上.*/ void PrintCodeFile(); /*将码文文件CodeFile显示在屏幕上*/void PrintHuffmanTree(); /*将哈夫曼树以直观的方式(凹入暗示法,或广义表,或其他树形暗示法)显示在屏幕上,同时写入文件TreePrintFile中*/void PrintHuffmanTree_aoru(int T,int layer=1); /*凹入暗示法显示哈夫曼树,由PrintHuffmanTree()调用*/};#include<string>#include<limits> //为使用整型最大值#include"HuffmanTree.h"using namespace std;//****************************************************** HuffmanTree::HuffmanTree(){Node=NULL;}//****************************************************** HuffmanTree::~HuffmanTree(){delete[]Node;}//****************************************************** void HuffmanTree::CreateHuffmanTree(){char Choose;cout<<"你要从文件中读入哈夫曼树(按1),还是从键盘输入哈夫曼树(按2)?";cin>>Choose;if(Choose=='2') {//键盘输入建立哈夫曼树CreateHuffmanTreeFromKeyboard();}//choose=='2'CreateHuffmanTreeFromFile();}}//****************************************************** void HuffmanTree::CreateHuffmanTreeFromKeyboard(){int Num;cout<<"\n请输入源码字符集个数:";cin>>Num;if (Num<=1){cout<<"没法建立少于2个叶子结点的哈夫曼树.\n\n"; return;}LeafNum=Num;Node=new HuffmanNode[2*Num-1];Info=new char[2*Num-1];for(int i=0;i<Num;i++) {//读入哈夫曼树的叶子结点信息cout<<"请输入第"<<i+1<<"个字符值";getchar();Info[i]=getchar(); //源文的字符存入字符数组Info[] getchar();cout<<"请输入该字符的权值或频度";cin>>Node[i].weight; //源文的字符权重存入Node[].weight Node[i].parent=-1;Node[i].lchild=-1;Node[i].rchild=-1;}for(i=Num;i<2*Num-1;i++){//轮回建立哈夫曼树内部结点int pos1=-1,pos2=-1;int max1=32767,max2=32767;for(int j=0;j<i;j++)//在根节点当选出权值最小的两个if(Node[j].parent==-1)//是否为根结点if(Node[j].weight<max1){max2=max1;max1=Node[j].weight;pos2=pos1;pos1=j;}elseif(Node[j].weight<max2){max2=Node[j].weight;pos2=j;}Node[pos1].parent=i;Node[pos2].parent=i;Node[i].lchild=pos1;Node[i].rchild=pos2;Node[i].parent=-1;Node[i].weight=Node[pos1].weight+Node[pos2].weight; } //forcout<<"哈夫曼树已成功构造完成.\n";char ch;cout<<"是否要替换本来的哈夫曼树文件(Y/N):"; cin>>ch;if (ch!='y'&&ch!='Y') return;else{ofstream fop;fop.open("hfmTree.dat",ios::out|ios::binary|ios::trunc); //打开文件if(fop.fail()){cout<<"\n哈夫曼树文件打开失败,没法将哈夫曼树写入hfmTree.dat文件.\n";return;}fop.write((char*)&Num,sizeof(Num)); //先写入哈夫曼树的叶子结点个数for(i=0;i<Num;i++){ //再写入源文字符集的所有字符(存储在Info[]中)fop.write((char*)&Info[i],sizeof(Info[i]));flush(cout);}for(i=0;i<2*Num-1;i++){ //最初写入哈夫曼树的各个结点(存储在Node[]中)fop.write((char*)&Node[i],sizeof(Node[i]));flush(cout);}fop.close(); //关闭文件cout<<"\n哈夫曼树已成功写入hfmTree.dat文件.\n";}}//****************************************************** void HuffmanTree::CreateHuffmanTreeFromFile(){ifstream fip;fip.open("hfmTree.dat",ios::binary|ios::in);if(fip.fail()){cout<<"哈夫曼树文件hfmTree.dat打开失败,没法建立哈夫曼树.\n";return;}fip.read((char*)&LeafNum,sizeof(LeafNum));if (LeafNum<=1){cout<<"哈夫曼树文件中的数据有误,叶子结点个数少于2个,没法建立哈夫曼树.\n";fip.close();return;}Info=new char[LeafNum];Node=new HuffmanNode[2*LeafNum-1];for(int i=0;i<LeafNum;i++)fip.read((char*)&Info[i],sizeof(Info[i]));for(i=0;i<2*LeafNum-1;i++)fip.read((char*)&Node[i],sizeof(Node[i]));fip.close();cout<<"哈夫曼树已成功构造完成.\n";}//****************************************************** void HuffmanTree::Encoder(){if(Node==NULL) CreateHuffmanTreeFromFile();if (LeafNum<=1){cout<<"内存无哈夫曼树.操纵撤消.\n\n";return;}}//ifchar *SourceText; //字符串数组,用于存放源文char Choose;cout<<"你要从文件中读入源文(按1),还是从键盘输入源文(按2)?";cin>>Choose;if(Choose=='1'){ifstream fip1("ToBeTran.txt");if(fip1.fail()){cout<<"源文文件打开失败!没法继续履行.\n";return;}char ch;int k=0;while(fip1.get(ch)) k++; //第一次读文件只统计文件中有多少个字符,将字符数存入kfip1.close();SourceText=new char[k+1]; //申请存放源文的字符数组空间ifstream fip2("ToBeTran.txt");//第二次读源文文件,把内容写入SourceText[]k=0;while(fip2.get(ch)) SourceText[k++]=ch;fip2.close();SourceText[k]='\0';cout<<"需编码的源文为:";cout<<SourceText<<endl;}else{ //从键盘输入源文string SourceBuff;cin.ignore();cout<<"请输入须要编码的源文(可输入任意长,按回车键结束):\n";getline(cin,SourceBuff,'\n');int k=0;while(SourceBuff[k]!='\0')k++;SourceText=new char[k+1];k=0;while(SourceBuff[k]!='\0'){SourceText[k]=SourceBuff[k];k++;}SourceText[k]='\0';cout<<"覆盖已有的编码原文件?(Y/N)";char ch;cin>>ch;if(ch=='y'||ch=='Y'){ofstream fip2;fip2.open("ToBeTran.txt");if(!fip2){cerr<<"文件打开失败!"<<endl;abort();}fip2<<SourceText<<endl;fip2.close();cout<<"需编码的源文已写入ToBeTran.txt中"<<endl;}}//开始编码ofstream fop("CodeFile.dat",ios::trunc); //打开码文存放文件char *code;code=new char[LeafNum]; //存放一个源文字符的编码int k=0;while(SourceText[k]!='\0') //源文串中从第一个字符开始逐一编码{int star=0;char ch=SourceText[k];for(int i=0;i<LeafNum;i++)if(Info[i]==ch)//求出该文字所在的单元编号break;int j=i;while(Node[j].parent!=-1){j=Node[j].parent;if(Info[Node[j].lchild]==Info[i]) code[star++]='0';else code[star++]='1';i=j;}code[star]='\0';for(i=0;i<star/2;i++){int j=code[i];code[i]=code[star-i-1];code[star-i-1]=j;i=0; //将源文的当前字符的对应编码写入码文文件while(code[i]!='\0'){fop<<code[i];i++;}k++; //源文串中的字符后移一个}fop.close();cout<<"已完成编码,码文已写入文件CodeFile.dat中.\n\n"; }//****************************************************** void HuffmanTree::Decoder(){if(Node==NULL){CreateHuffmanTreeFromFile();if (LeafNum<=1){cout<<"内存无哈夫曼树.操纵撤消.\n\n";return;}//将码文从文件CodeFile.dat中读入 CodeStr[] ifstream fip1("CodeFile.dat");if(fip1.fail()){cout<<"没有码文,没法译码.\n";return;}char* CodeStr;int k=0;char ch;while(fip1.get(ch)){k++;}fip1.close();CodeStr=new char[k+1];ifstream fip2("CodeFile.dat");k=0;while(fip2.get(ch)) CodeStr[k++]=ch;fip2.close();CodeStr[k]='\0';cout<<"经译码得到的源文为:";ofstream fop("TextFile.dat");int j=LeafNum*2-1-1; //j指向哈夫曼树的根int i=0; //码文从第一个符号开始,顺着哈夫曼树由根下行,按码文的当前符号决定下行到左孩子还是右孩子while(CodeStr[i]!='\0'){ //下行到哈夫曼树的叶子结点处,则译出叶子结点对应的源文字符if(CodeStr[i]=='0') j=Node[j].lchild;else j=Node[j].rchild;if(Node[j].rchild==-1){cout<<Info[j];fop<<Info[j];j=LeafNum*2-1-1;}i++;}fop.close();cout<<"\n译码成功且已存到文件TextFile.dat中.\n\n";}//****************************************************** void HuffmanTree::PrintCodeFile(){char ch;int i=1;ifstream fip("CodeFile.dat");ofstream fop("CodePrin.dat");if(fip.fail()){cout<<"没有码文文件,没法显示码文文件内容.\n"; return;}while(fip.get(ch)){cout<<ch;fop<<ch;if(i==50){cout<<endl;fop<<endl;i=0;}}cout<<endl;fop<<endl;fip.close();fop.close();}//****************************************************** void HuffmanTree::PrintHuffmanTree(){if(Node==NULL){CreateHuffmanTreeFromFile();if (LeafNum<=1){cout<<"内存无哈夫曼树.操纵撤消.\n\n";return;}}ofstream fop("TreePrint.dat",ios_base::trunc);fop.close();PrintHuffmanTree_aoru(2*LeafNum-1-1,0);}//****************************************************** void HuffmanTree::PrintHuffmanTree_aoru(int T,int layer){for(int i=0;i<layer;i++) cout<<"___";cout<<Node[T].weight<<endl;if(Node[T].lchild!=-1)PrintHuffmanTree_aoru(Node[T].lchild,++layer);if(Node[T].rchild!=-1)PrintHuffmanTree_aoru(Node[T].rchild,layer--);}#include<string.h>#include<stdlib.h>using namespace std;int main(){HuffmanTree huftree;char Choose;while(1){cout<<"\n\n**********************欢迎使用哈夫曼编码/译码零碎***********************"<<endl;cout<<"您可以进行以下操纵:"<<endl;cout<<"1 建立哈夫曼树 3 译码(码文已在文件CodeFile中) 5 显示哈夫曼树"<<endl;cout<<"2 编码(源文已在文件ToBeTran中,或键盘输入) 4 显示码文 6 退出 "<<endl;cout<<"请选择一个操纵:";cin>>Choose;switch(Choose){case '1':huftree.CreateHuffmanTree();break;case '2':huftree.Encoder();break;case '3':huftree.Decoder();break;case '4':huftree.PrintCodeFile();break;case '5':huftree.PrintHuffmanTree();break;case '6':cout<<"\n*************************感谢使用本零碎!***********************\n\n";system("pause");return 0;}//switch}//while}//main【用户手册】进入哈弗曼树零碎,出现以下界面:1建立弗曼树2、编码(源文中读入,键盘输入)3、译码4、显示码文 5、显示哈弗曼树 6、退出用户根据该提示,选择前面数字,就能进入各个功能函数,实现函数功能.【运转结果】截图一:截图二:截图三:截图四:【心得体会】本实验是搜集相干材料,然后本人添加功能函数的代码实现的.是以,在完成未完成的功能函数之前还必必要仔细浏览所给出代码,全体观察各个部分之前的联系,搞清楚已给出和未完成的代码功能以后,才根据算法,设计出该功能的函数代码.在完成实验时,有发古代码也有纰漏的地方,如在源文件读入的时候,多出了一个值,得要添加下表减这个代码来去掉.还有就是在译码的时候,因为变量定义的混淆,在编译的时候通过,但履行时却出现料想不到的结果,在本人仔细观察、思考之前也还没找出错误的地方.后来通过请教老师,在和老师讨论检查以后才晓得了错误之所在,最初改正错误.实验成功完成.【参考文献】数据结构与算法(课本)C++说话基础。
哈夫曼编码译码器实验报告
哈夫曼编码译码器实验报告实验名称:哈夫曼编码译码器实验一、实验目的: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.比较编码前后字符串的内容,结果正确。
五、实验总结:通过本次实验,我了解了哈夫曼编码的原理和应用,并且实现了一个简单的哈夫曼编码的编码和译码器。
在实验过程中,我充分运用了数据结构中的树的知识,构建了一个哈夫曼树,并生成了编码表。
通过编码和译码过程,我进一步巩固了对树的遍历和节点查找的理解。
实验结果表明,本次哈夫曼编码的编码和译码过程正确无误。
在实验的过程中,我发现哈夫曼编码对于频率较高的字符具有较短的编码,从而实现了对字符串的高效压缩。
同时,哈夫曼编码还可以应用于数据传输和存储中,提高数据的传输效率和存储空间的利用率。
通过本次实验,我不仅掌握了哈夫曼编码的编码和译码过程,还深入了解了其实现原理和应用场景,加深了对数据结构和算法的理解和应用能力。
哈夫曼编译码器课程设计报告
《数据结构》课程设计报告题目: 哈夫曼编/译码器 专业: 计算机科学与技术(对口)班级: 13(3) 姓名: 陈霞指导教师:彭飞2015-2016学年 第1学期成绩:计算机学院2015年11月12日目录1 设计内容及要求 (3)1.1 内容 (3)1.2 要求 (4)2 概要设计 (5)2.1 抽象数据类型定义 (5)2.2 模块划分 (6)3 设计过程及代码 (7)3.1 设计过程 (7)3.2 代码 (11)4 设计结果与分析 (17)5 参考文献 (20)1设计内容及要求1.1 内容利用哈夫曼编码进行信息通信可以大大提高信道利用率,缩短信息传输时间,降低传输成本。
但是,这要求在发送端通过一个编码系统对待传数据预先编码,在接收端将传来的数据进行译码(复原)。
对于双工信道(即可以双向传输信息的信道),每端都需要一个完整的编/译码系统。
试为这样的信息收发站写一个哈夫曼编/译码系统。
1.2 要求一个完整的系统应具有以下功能:(1)I:初始化(Initialization)。
从终端读入字符集大小n,以及n个字符和n个权值,建立哈夫曼树,并将它存于文件hfmTree中。
(2)E:编码(Encoding)。
利用已建好的哈夫曼树(如不在内存,则从文件htmTree中读入),对文件ToBeTran中的正文进行编码,然后将结果存入文件CodeFile中。
(3)D:译码(Decoding)。
利用已建好的哈夫曼树将文件CodeFile中的代码进行译码,结果存入文件TextFile中。
(4)P:印代码文件(Print)。
将文件CodeFile以紧凑格式显示在终端上,每行50个代码。
同时将此字符形式的编码写入文件CodePrint中。
(5)T:印哈夫曼树(Tree Printing)。
将已在内存中的哈夫曼树以直观的方式(树或凹入表形式)显示在终端上,同时将此字符形式的哈夫曼树写入文件TreePrint中。
[测试数据](1)数据一:已知某系统在通信联络中只可能出现8种字符,其概率分别为0.05,0.29,0.07,0.08,0.14,0.23,0.03,0.11,以此设计哈夫曼编码。
哈夫曼编译码器课程设计报告完整版
哈夫曼编译码器课程设计报告完整版XXX学院本科数据结构课程设计总结报告设计题目:实验一、哈夫曼编/译码器学生姓名:XXX系别:XXX专业:XXX班级:XXX学号:XXX指导教师:XXX XXX6 月 21日xxx学院课程设计任务书题目一、赫夫曼编译码器专业、班级 xxx学号 xxx 姓名 xxx主要内容、基本要求、主要参考资料等:1. 主要内容利用哈夫曼编码进行信息通信可大大提高信道利用率,缩短信息传输时间,降低传输成本。
要求在发送端经过一个编码系统对待传数据预先编码;在接收端将传来的数据进行译码(复原)。
对于双工信道(既能够双向传输信息的信道),每端都需要一个完整的编/译码系统。
试为这样的信息收发站写一个哈夫曼的编/译码系统。
2. 基本要求系统应具有以下功能:(1)C:编码(Coding)。
对文件tobetrans中的正文进行编码,然后将结果存入文件codefile中,将以此建好的哈夫曼树存入文件HuffmanTree中(2)D:解码(Decoding)。
利用已建好的哈夫曼树将文件codefile中的代码进行译码,结果存入textfile中。
(3)P:打印代码文件(Print)。
将文件codefile以紧凑格式显示在终端上,每行50个代码。
同时将此字符形式的编码文件写入文件codeprint中。
(4)T:打印哈夫曼树(Tree Printing)。
将已在内存中的哈夫曼树以直观的方式(树或凹入表形式)显示在终端上,同时将此字符形式的哈夫曼树写入文件treeprint中。
3. 参考资料:数据结构(C语言版)严蔚敏、吴伟民编著;数据结构标准教程胡超、闫宝玉编著完成期限: 6月21 日指导教师签名:课程负责人签名:6月 21 日一、设计题目(任选其一)实验一、哈夫曼编/译码器二、实验目的1巩固和加深对数据结构的理解,提高综合运用本课程所学知识的能力;2 深化对算法课程中基本概念、理论和方法的理解;3 巩固构造赫夫曼树的算法;4 设计试验用程序实验赫夫曼树的构造。
数据结构课程设计报告哈夫曼编码译码器
西安郵電學院数据结构课程设计报告题目1:哈夫曼编码/译码器题目2:学生信息管理系统系部名称:通信工程系专业名称:通信工程班级:****学号:*****学生姓名:****指导教师:*****时间:2009年12月16日至2009年12月25日题目1.哈夫曼编码/译码器一、课程设计目的通过对哈夫曼编码/译码器的实现,熟悉了解Huffman树的创建过程以及存储结构,对Huffman编码/译码过程及原则有了更深层次的认识,锻炼了动手能力,使知识更好的学以致用,为解决数据压缩问题提供方法。
二、课程设计内容通过统计文件中各字符的出现频率,建立Huffman树,再通过建立的已经Huffman的树,对文件中各字符进行编码,将结果存入新的文件中,然后从文件中读取Huffman编码,进行解码,结果存入新的文件中,并与源文件进行比较。
三、需求分析1.统计字符频率:存文件中读入字符,并对各字符出现频率进行统计;2.建立Huffman树:将各字符出现的频率作为权值,建立Huffman树;3.Huffman编码:通过已经建立的Huffman树,对个各字符进行编码,并存入新的文件中;4.译码:读取存放Huffman编码的文件,对文件中编码进行译码,把译码结果存入新的文件中;5.结果验证:将译码结果与原文件内容进行比较;四、概要设计1. 系统结构图(功能模块图)2.功能模块说明1:统计字符频率: 定义结构体 typedef struct str {char data; char num; }str;其中data 域存放字符名称,num 域存放字符出现频率,读取文件ywq1.txt ,通过循环比较将结果赋入S2[128]中;2:创建Huffman 树: 定义结构体 typedef struct {char data; int weight; int parent; int lchild;开始 main ()统计字符频率创建Huffman 树对文件编码对编码译码出现次数 字符名称初 始 化 结点赋值Huffma 编码 存入文件读取编码 存入文件对编码译码 对编码译码成功 失败int rchild;}HTNode,HuffmanTree[M+1];作为Huffman树存储节点类型,调用CrtHuffmanTree()函数,初始化各节点均为0;然后将存储字符频率的数组S2的值赋值给各节点,字符出现频率作为权值,创建Huffman树;3:对文件编码:定义结构体typedef struct{char data;char bits[N+1];}CodeNode,HuffmanCode[N];作为HuffmanCode的存储类型,调用CrtHuffmanCode()函数,从叶子节点向上回溯,是lchild则赋值‘0’,是rchild则赋值为‘1’,对各字符编码,再调用WriteToFile()函数,将结果写入文件ywq2.txt中;4:对文件译码:读取编码文件ywq2.txt中数据,调用DecodHuffmanCode()函数,从根节点开始,读取‘1’,走向rchild,读取‘0’, 走向lchild,直到叶子节点,将叶子节点data域的值写入文件ywq3.txt中;五、详细设计及运行结果1.读文件统计字符频率(read()函数中实现):源文件ywq1.txt :打开源文件 ywq1.txt读文件内的字符,初始化数组s1文件是否结束将字符存入数组 S1[ch].num++读下一个字符给数组末尾加上结束标志“\0”关闭文件是否开始结束运行结果:2:创建Huffman树,CrtHuffmanTree():运行结果:初始化结构体数组htCrtHuffmanTree()有n棵二叉树n > 1选权值最小2个二叉树权值相加得新二叉树n - 1n = 1建立Huffman树结束3:Huffman编码,CrtHuffmanCode();运行结果:CrtHuffmanCode()根cd[--start] = ‘0’cd[--start] = ‘1’否Lchild Rchild cd[start] 赋给hc[i].bits是结束对应字符编码写入文件ywq2.txt编码文件ywq2.txt:3:译码,DecodHuffmanCode():运行结果:文件ywq3.txt:DecodHuffmanCode()打开文件ywq2.txt 读取字符ch文件结束否否找根节点ch = ‘0’, 找lchild ; ch = ‘1’, 找rchild ;叶子节点是是保存 ywq3.txt是结束4:结果验证:比较源文件ywq1.txt 与译码文件ywq3.txt 可知,译码结果与源文件一致。
2023年数据结构哈夫曼编码实验报告
数据构造试验汇报――试验五简朴哈夫曼编/译码旳设计与实现本试验旳目旳是通过对简朴哈夫曼编/译码系统旳设计与实现来纯熟掌握树型构造在实际问题中旳应用。
此试验可以作为综合试验,阶段性试验时可以选择其中旳几种功能来设计和实现。
一、【问题描述】运用哈夫曼编码进行通信可以大大提高信道运用率,缩短信息传播时间,减少传播成本。
不过,这规定在发送端通过一种编码系统看待传数据预先编码,在接受端将传来旳数据进行译码,此试验即设计这样旳一种简朴编/码系统。
系统应当具有如下旳几种功能:1、接受原始数据。
从终端读入字符集大小n,以及n个字符和n个权值,建立哈夫曼树,并将它存于文献nodedata.dat中。
2、编码。
运用已建好旳哈夫曼树(如不在内存,则从文献nodedata.dat中读入),对文献中旳正文进行编码,然后将成果存入文献code.dat中。
3、译码。
运用已建好旳哈夫曼树将文献code.dat中旳代码进行译码,成果存入文献textfile.dat中。
4、打印编码规则。
即字符与编码旳一一对应关系。
二、【数据构造设计】1、构造哈夫曼树时使用静态链表作为哈夫曼树旳存储。
在构造哈夫曼树时,设计一种构造体数组HuffNode保留哈夫曼树中各结点旳信息,根据二叉树旳性质可知,具有n个叶子结点旳哈夫曼树共有2n-1个结点,因此数组HuffNode 旳大小设置为2n-1,描述结点旳数据类型为:typedef struct{int weight;//结点权值int parent;int lchild;int rchild;char inf;}HNodeType;2、求哈夫曼编码时使用一维构造数组HuffCode作为哈夫曼编码信息旳存储。
求哈夫曼编码,实质上就是在已建立旳哈夫曼树中,从叶子结点开始,沿结点旳双亲链域回退到根结点,没回退一步,就走过了哈夫曼树旳一种分支,从而得到一位哈夫曼码值,由于一种字符旳哈夫曼编码是从根结点到对应叶子结点所通过旳途径上各分支所构成旳0、1序列,因此先得到旳分支代码为所求编码旳低位码,后得到旳分支代码位所求编码旳高位码,因此设计如下数据类型:#define MAXBIT 10typedef struct{int bit[MAXBIT];int start;}HcodeType;3、文献nodedata.dat、code.dat和textfile.dat。
数据结构课程设计哈夫曼编码译码器
题目一: 哈夫曼编码与译码一、任务设计一个运用哈夫曼算法的编码和译码系统, 反复地显示并解决以下项目, 直到选择退出为止。
规定:1) 将权值数据存放在数据文献(文献名为data.txt, 位于执行程序的当前目录中) ;2) 初始化:键盘输入字符集记录字符权值、自定义26个字符和26个权值、记录文献中一篇英文文章中26个字母, 建立哈夫曼树;3) 编码: 运用建好的哈夫曼树生成哈夫曼编码;4) 输出编码(一方面实现屏幕输出, 然后实现文献输出);5)译码(键盘接受编码进行译码、文献读入编码进行译码);6) 界面优化设计。
二、流程图三、代码分解 //头文献 #include<stdio.h> #include<string.h> #include<stdlib.h> #include <conio.h> #define N 1000 #define M 2*N-1 #define MAXcode 6000 //函数声明void count(CHar &ch,HTNode ht[]);void editHCode(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]); //编码函数void printyima(HTNode ht[],HCode hcd[],int n,char bianma[]); //译码函数 void creatHT(HTNode ht[],int n);字符集记录符集记录权值 权值 至文献“哈夫曼树。
t xt” 菜单1.从键盘输入字符集进行编码2.从文献读入字符集进行编码1.从键盘输入编码进行译码2.从文献读入编码进行译码0.返回上级菜单 0.返回上级菜单void CreateHCode (HTNode ht[],HCode hcd[],int n);void DispHCode(HTNode ht[],HCode hcd[],int n);void input_key(CHar &ch);void input_file(CHar &ch);void input_cw(HTNode ht[]);void bianma1(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]); void bianma2(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]); void yima1(HTNode ht[],HCode hcd[],int n,char bianma[]);void yima2(HTNode ht[],HCode hcd[],int n,char bianma[]);void creat_cw();void bianmacaidan();void yimacaidan();void bianmayima();int caidan();//结构体typedef struct{char data;int parent;int weight;int lchild;int rchild;}HTNode;typedef struct{char cd[N];int start;}HCode;typedef struct{char s[N];int num;}CHar;CHar ch;HTNode ht[M];HCode hcd[N];//主函数int main(){int xh;while(1){system("color 1f"); //操作菜单背景颜色 xh=caidan(); //调用菜单函数switch(xh) //switch语句 {case 1:system("cls");creat_cw();break;case 2:system("cls");creatHT(ht,n);break;case 3:system("cls");CreateHCode(ht,hcd,n);DispHCode(ht,hcd,n);break;case 4:system("cls");bianmayima();break;case 0:system("cls");printf("\n\n\n\n\n\n\n\n\n\t\t\t\t感谢使用本系统!\n\n\n\n\n\n\n \t\t\t");exit(0);default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}return 0;}//菜单函数int caidan() //菜单函数模块//{int xh;printf("\n\n\n");printf("\t\t 欢迎使用哈夫曼编码译码系统\n");printf("\t\t \n");printf("\t\t*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n");printf("\t\t*= =*\n");printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n");printf("\t\t*= 1.建立字符权值=*\n");printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n"); printf("\t\t*= 2.建立并输出哈夫曼树=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n"); printf("\t\t*= 3.生成并查看哈夫曼编码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n"); printf("\t\t*= 4.编码与译码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n"); printf("\t\t*= 0.退出系统=*\n"); printf("\t\t*= =*\n"); printf("\t\t*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d", &xh);return xh; //返回从键盘接受的选项}void bianmayima(){int xh;while(1){printf("\n\n\n\n\n");printf("\t\t 编码与译码\n"); printf("\t\t \n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n");printf("\t\t*= 1.编码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 2.译码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 0.返回上级菜单=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d",&xh);switch(xh) //switch语句{case 1:system("cls");bianmacaidan();break;case 2:system("cls");yimacaidan();break;case 0:system("cls");return;default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}}void yimacaidan(){int xh;while(1){printf("\n\n\n\n\n");printf("\t\t 译码\n"); printf("\t\t \n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 1.键盘输入编码进行译码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 2.文献读入编码进行译码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 0.返回上级菜单=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d",&xh);switch(xh) //switch语句{case 1:system("cls");yima1(ht,hcd,n,bianma);break;case 2:system("cls");yima2(ht,hcd,n,bianma);break;case 0:system("cls");return;default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}}void bianmacaidan(){int xh;while(1){printf("\n\n\n\n\n");printf("\t\t 编码\n"); printf("\t\t \n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 1.键盘输入字符集编码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 2.文献读入文章编码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 0.返回上级菜单=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d",&xh);switch(xh) //switch语句{case 1:system("cls");bianma1(ht,hcd,ch,n,bianma);break;case 2:system("cls");bianma2(ht,hcd,ch,n,bianma);break;case 0:system("cls");return;default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}}void creat_cw(){int xh2;while(1){printf("\n\n\n\n\n");printf("\t\t 建立字符权值\n"); printf("\t\t \n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 1.从键盘输入字符集进行记录=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 2.从文献读入字符集记录=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 3.自定义字符权值=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 0.返回上级菜单=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d",&xh2);switch(xh2) //switch语句{case 1:system("cls");input_key(ch);break;case 2:system("cls");input_file(ch);break;case 3:system("cls");input_cw(ht);break;case 0:system("cls");return;default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}}//建立字符权值模块void input_key(CHar &ch){int i,j=0;char st[N];printf("请输入字符集(以‘#’结束):\n");for(i=0;i<N;i++){scanf("%c",&st[i]);if(st[i]=='#'){st[i]='\0';break;}}strcpy(ch.s,st);count(ch,ht);printf("按任意键返回!");getch();system("cls");return;}void input_file(CHar &ch){int i;FILE*fp;char filename[20];printf("请输入要打开的文献名(*.txt):");scanf("%s",&filename);if((fp=fopen(filename,"r"))==NULL){printf("\n\t\t文献打开失败");return;}for(i=0;!feof(fp);i++){fread(&ch.s[i],sizeof(char),1,fp);}printf("读入成功!\n");printf("文献中的字符集为:%s\n",ch.s);fclose(fp);count(ch,ht);printf("按任意键返回!");getch();system("cls");return;}void input_cw(HTNode ht[]){int i,w,s,j;char a;printf("要输入的字符总个数是?:");scanf("%d",&s);n=s;printf("请输入字符及其权值:\n");for(i=0;i<s;i++){printf("请输入第%d个字母:",i+1);scanf("%s",&a);ht[i].data=a;printf("请输入其权值:");scanf("%d",&w);ht[i].weight=w;}FILE *fp;if((fp=fopen("data.txt","w"))==0){printf("\n\t\t文献打开失败");return;}printf("\n定义权值成功!\n\n");printf("各字符及其权值为:\n\n");fprintf(fp,"各字符及其权值为:\n");printf(" 字符\t权值");fprintf(fp," 字符\t权值");for(j=0;j<i;j++){ printf("\n");fprintf(fp,"\n");printf(" %-8c%-8d",ht[j].data,ht[j].weight);fprintf(fp," %-8c%-8d%",ht[j].data,ht[j].weight); }printf("\n");printf("\n字符权值已输出至文献“data.txt”!");fclose(fp);printf("输入完毕, 按任意键返回!");getch();system("cls");return;}//记录字符权值函数void count(CHar &ch,HTNode ht[]){int i,j,m=0;char c[N];int sum[N]={0};for(i=0;ch.s[i]!='\0';i++){for(j=0;j<m;j++)if(ch.s[i]==c[j]||(c[j]>='a'&&c[j]<='z'&&ch.s[i]+32==c[j])) break;if(j<m)sum[j]++;else{if(ch.s[i]>='A'&&ch.s[i]<='Z')c[j]=ch.s[i]+32;else c[j]=ch.s[i];sum[j]++;m++;}}for(i=0;i<m;i++){ht[i].data=c[i];ht[i].weight=sum[i];}n=m;FILE *fp;if((fp=fopen("data.txt","w"))==0) {printf("\n\t\t文献打开失败"); return;}printf("\n记录权值成功!\n\n"); printf("各字符及其权值为:\n\n"); fprintf(fp,"各字符及其权值为:\n"); printf(" 字符\t权值");fprintf(fp," 字符\t权值");for(j=0;j<m;j++){ printf("\n");fprintf(fp,"\n");printf(" %-8c%-8d",ht[j].data,ht[j].weight);fprintf(fp," %-8c%-8d%",ht[j].data,ht[j].weight);}printf("\n");printf("\n字符权值已输出至文献“data.txt”!");fclose(fp);}//构造哈夫曼树void creatHT(HTNode ht[],int n){FILE *fp;if((fp=fopen("哈夫曼树.txt","w"))==0){printf("\n\t\t文献打开失败");return;}int i,j,k,lnode,rnode;int min1,min2;for (i=0;i<2*n-1;i++)ht[i].parent=ht[i].lchild=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[lnode].parent=i;ht[rnode].parent=i;ht[i].weight=ht[lnode].weight+ht[rnode].weight;ht[i].lchild=lnode;ht[i].rchild=rnode;}printf("建立huffman树成功!\n");printf("输出huffman树:\n");fprintf(fp,"输出huffman树:\n");printf("\t字符\t权值\t父节点\t 左子节点\t右子节点");fprintf(fp,"\t字符\t权值\t父节点\t 左子节点\t右子节点");for(j=1;j<i;j++){ printf("\n");fprintf(fp,"\n");printf("\t %-8c%-8d%-10d%-14d%-10d",ht[j].data,ht[j].weight,ht[j].parent,ht[i]. lchild,ht[j].rchild);fprintf(fp,"\t %-8c%-8d%-10d%-14d%-10d",ht[j].data,ht[j].weight,ht[j].parent,h t[i].lchild,ht[j].rchild);}printf("\n");printf("哈夫曼树已输出至文献“哈夫曼树.txt”!按任意键返回!");fclose(fp);getch();system("cls");return;}//生成哈夫曼编码void CreateHCode (HTNode ht[],HCode hcd[],int n){int i,f,c,j=0;HCode hc;for(i=0;i<n;i++){hc.start=n;c=i;hc.cd[hc.start--]='0';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++;for(j=0;j<hc.start;j++)hc.cd[j]=' ';hcd[i]=hc;}}void DispHCode(HTNode ht[],HCode hcd[],int n) {FILE *fp;if((fp=fopen("哈夫曼编码.txt","w"))==0){printf("\n\t\t文献打开失败");return;}int i,k;int sum=0,m=0,j;printf("输出字符哈夫曼编码:\n"); fputs("输出字符哈夫曼编码:\n",fp); for (i=0;i<n;i++){j=0;printf("%c:\t",ht[i].data);fprintf(fp,"\n%c:\t",ht[i].data);for (k=hcd[i].start;k<=n;k++){printf("%c",hcd[i].cd[k]);j++;fprintf(fp,"%c",hcd[i].cd[k]); }m+=ht[i].weight;sum+=ht[i].weight*j;printf("\n");}printf("\n哈夫曼编码已保存至文献“哈夫曼编码.txt!按任意键返回!”");fclose(fp);getch();system("cls");}//编码函数void bianma1(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]){int i;char str[N];printf("请输入要编码的字符集(以‘#’结束):\n");for(i=0;i<N;i++){scanf("%c",&str[i]);if(str[i]=='#'){str[i]='\0';break;}}strcpy(ch.s,str);ch.num=strlen(str);editHCode(ht,hcd,ch,n,bianma);getch();system("cls");}void bianma2(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]) {int i;FILE*fp;char filename[20];printf("请输入要打开的文献名(*.txt):");scanf("%s",&filename);if((fp=fopen(filename,"r"))==NULL){printf("\n\t\t文献打开失败");return;}for(i=0;!feof(fp);i++){fread(&ch.s[i],sizeof(char),1,fp);}ch.num=strlen(ch.s);printf("\n读入成功!\n");printf("文献中的字符集为:\n%s",ch.s);fclose(fp);editHCode(ht,hcd,ch,n,bianma);system("cls");return;}//译码函数void yima1(HTNode ht[],HCode hcd[],int n,char bianma[]) {int i;char code[MAXcode];printf("请输入编码进行译码(以‘#’结束):\n");for(i=0;i<MAXcode;i++){scanf("%c",&code[i]);if(code[i]=='#'){code[i]='\0';break;}}strcpy(bianma,code);printyima(ht,hcd,n,bianma);printf("\n译码完毕!按任意键返回!");getch();system("cls");return;}void yima2(HTNode ht[],HCode hcd[],int n,char bianma[]) {int i;FILE*fp;char filename[20];printf("请输入要打开的文献名(*.txt):");scanf("%s",&filename);if((fp=fopen(filename,"r"))==NULL){printf("\n\t\t文献打开失败");return;}for(i=0;!feof(fp);i++){fread(&bianma[i],sizeof(char),1,fp);}printf("读入成功!\n");printf("文献中的编码是:%s\n",bianma);printyima(ht,hcd,n,bianma);printf("\n译码完毕!按任意键返回!");getch();system("cls");}四、调试结果主菜单建立字符权值选择2.从文献读入字符进行记录输入测试文献名“cs.txt”输出个字符权值建立哈夫曼树并输出至文献生成哈夫曼编码并保存至文献编码选择2.从文献读入字符集编码编码结果保存至文献译码选择2.从文献读入编码, 读入上一步的编码译码完毕, 返回!退出系统。
编码译码实验报告
一、实验目的1. 理解编码译码的基本原理和方法。
2. 掌握哈夫曼编码和译码的实现过程。
3. 通过实验,提高编程能力和数据结构应用能力。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验内容1. 哈夫曼编码与译码(1)哈夫曼编码的原理哈夫曼编码是一种变长编码,通过为不同频率的字符分配不同的编码长度,达到压缩数据的目的。
哈夫曼编码的核心是构建一棵哈夫曼树,树中每个叶子节点对应一个字符,非叶子节点对应两个子节点的编码。
(2)哈夫曼编码的实现首先,根据输入的字符及其频率,构建哈夫曼树。
然后,从根节点开始,对每个叶子节点进行编码,编码规则为从根节点到叶子节点的路径,左子节点编码为“0”,右子节点编码为“1”。
(3)哈夫曼译码的实现根据哈夫曼编码的编码规则,将编码后的数据还原成原始字符。
从编码数据的第一个比特开始,根据编码规则,逐步还原出原始字符。
2. 字符串编码与译码(1)字符串编码的原理字符串编码是将字符串中的字符转换成二进制表示,以达到压缩数据的目的。
常见的字符串编码方法有ASCII编码、UTF-8编码等。
(2)字符串编码的实现以ASCII编码为例,将字符串中的每个字符转换为对应的ASCII码,然后将其转换为二进制表示。
(3)字符串译码的实现将编码后的二进制数据转换回对应的ASCII码,再将ASCII码转换成字符。
四、实验步骤1. 创建一个新的C++项目,命名为“编码译码实验”。
2. 在项目中创建两个源文件:main.cpp和编码译码.cpp。
3. 在main.cpp中编写代码,实现以下功能:(1)从文件中读取字符串,进行哈夫曼编码。
(2)将编码后的数据写入文件。
(3)从文件中读取编码后的数据,进行哈夫曼译码。
(4)将译码后的字符串输出到屏幕。
4. 在编码译码.cpp中编写代码,实现以下功能:(1)构建哈夫曼树。
(2)实现哈夫曼编码和译码算法。
哈夫曼编码译码实训报告
一、实训目的本次实训旨在通过实际操作,使学生掌握哈夫曼编码的基本原理和方法,熟悉哈夫曼树的构建过程,并能够熟练地进行哈夫曼编码和译码操作。
通过实训,提升学生对数据压缩技术的理解和应用能力。
二、实训内容1. 哈夫曼树构建- 收集给定字符串中每个字符的出现频率。
- 根据字符频率构建哈夫曼树,其中频率高的字符对应较大的权重。
- 使用优先队列(最小堆)实现哈夫曼树的构建。
2. 哈夫曼编码- 遍历哈夫曼树,为每个叶子节点分配唯一的编码,左分支为0,右分支为1。
- 根据分配的编码生成字符编码表。
3. 哈夫曼译码- 使用生成的编码表,将编码字符串转换回原始字符串。
三、实训步骤1. 数据准备- 选择一段英文或中文文本作为输入数据。
2. 构建哈夫曼树- 统计输入数据中每个字符的出现频率。
- 使用优先队列构建哈夫曼树。
3. 生成哈夫曼编码- 遍历哈夫曼树,为每个叶子节点分配编码。
- 生成字符编码表。
4. 编码数据- 使用哈夫曼编码表对输入数据进行编码。
5. 译码数据- 使用哈夫曼编码表对编码后的数据进行译码。
6. 结果分析- 比较编码前后数据的大小,分析哈夫曼编码的压缩效果。
四、实训结果1. 哈夫曼树构建- 成功构建了给定字符串的哈夫曼树。
2. 哈夫曼编码- 成功生成了每个字符的哈夫曼编码。
3. 哈夫曼译码- 成功将编码后的数据译码回原始字符串。
4. 压缩效果分析- 通过对比编码前后数据的大小,验证了哈夫曼编码的压缩效果。
五、实训总结1. 哈夫曼编码原理- 哈夫曼编码是一种基于字符频率的变长编码方法,能够有效降低数据传输的冗余度。
2. 哈夫曼树构建- 哈夫曼树的构建是哈夫曼编码的关键步骤,通过优先队列(最小堆)实现。
3. 哈夫曼编码与译码- 哈夫曼编码和译码过程相对简单,但需要正确处理编码表和字符编码。
4. 实训收获- 通过本次实训,掌握了哈夫曼编码的基本原理和方法,熟悉了哈夫曼树的构建过程,并能够熟练地进行哈夫曼编码和译码操作。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
内蒙古科技大学本科生课程设计说明书题目:数据结构课程设计——哈夫曼编码和译码学生姓名:***学号:**********专业:软件工程班级:1班指导教师:***日期:2016年1月8日内蒙古科技大学课程设计任务书目录内蒙古科技大学课程设计任务书 (1)第一章需求分析 (2)1.1程序的功能 (3)1.2输入输出的要求 (3)第二章概要设计 (3)2.1总体设计 (3)2.2数据类型设计(或数据结构设计) (4)2.3接口设计 //函数声明 (4)第三章详细设计 (6)3.1工程视图 (6)3.2类图视图 (6)3.3函数的调用关系 ············································错误!未定义书签。
3.4主程序流程图 (8)3.5主要算法流程图 (9)第四章测试分析 (11)4.1测试程序执行情况 (11)第五章用户手册(可选) (12)第六章课程设计总结 (13)附录:程序代码 (13)第一章需求分析1.1.程序的功能能对输入的字符串实现Huffman编码,且能利用生成的编码对Huffman代码串进行译码,输出相应字符串。
2.2.输入输出的要求首先,输入一个字符串,程序会列出字符串中包含的字符种类及每一种字符出现的次数,然后输出通过Huffman编码得到的各种字符的Huffman编码。
此时程序要求输入一串Huffman代码串,输入完毕程序会判断输入的代码串是否合法,若合法则输出译码结果。
第二章概要设计2.1总体设计2.2数据类型设计(或数据结构设计)enum Child{none,lchild,rchild}; //采用枚举,标记是左孩子还是右孩子class element //元素类{public://类的公有成员elememt(); //构造函数void change(char l,char *c,int p,Child h,int w) //对对象进行修改操作void getparent(int p) //对父结点的值进行修改操作void geta(Child h) //对孩子结点进行修改操作void getweight(int w) //对权值进行修改操作int returnweight() //返回权值操作friend void Select(element h[],int k,int *a,int *b);//友元函数的声明friend void HuffmanTreeCode(element HT[]);friend void HuffmanTreeYima(element huff[],char cod[],int b);private://类的私有成员char letter,*code; //letter为字符,*code指向编码字符串int weight; //权值int parent; //父结点Child a; //为父结点的左孩子还是右孩子};2.3接口设计主函数:对输入的字符段进行存储,并对字符数和对应的权值(字符个数)进行统计存储。
哈夫曼树初始化函数:对给定的字符数和权值,创建一棵哈夫曼树。
权值大小比较函数:找到每次所给集合的最小值和次小值,并返回给哈夫曼树初始化函数。
哈夫曼树编码函数:对创建的哈夫曼树,为左孩子的赋值为0,右孩子赋值为1,然后对叶子结点依次编码。
哈夫曼树译码函数:对输入的01二进制数一一与叶子结点的编码依次比较匹配。
第三章详细设计3.1工程视图图3.1工程视图3.2类图视图图3.2类图视图3.3 函数的调用关系图3.3函数调用关系图3.4主程序流程图图3.4主程序流程图3.5主要算法流程图图3.5.1哈夫曼编码函数图3.5.2哈夫曼译码函数第四章测试分析4.1测试程序执行情况准备典型的测试数据和测试方案,包括正确的输入及输出结果和含有错误的输入及输出结果:输入:编码输入演示图输出:编码输出演示图正确输入哈夫曼编码代号:正确译码输入演示图输出:正确输入译码译码结果输出演示图错误输入哈夫曼编码代号:错误输入哈夫曼编码代码串示意图输出:错误输入哈夫曼编码代码串输出示意图第五章用户手册(可选)1.运行程序,程序首先会要求你输入需要编码的字符串,输入完毕按回车即可进行编码:程序启动画面输出:编码输出画面2.输出编码后,程序会提示输入需要译码的哈夫曼编码串,输入后按回车即可进行译码:译码输入界面输出:译码输出界面3.译码结束后,输入N可退出程序,输入Y可继续进行译码。
第六章课程设计总结此次课程设计,我编写程序的时候遇到了不少问题,在攻克这些问题,最终实现课题任务的过程中,我学到了不少东西:首先,在完成一个课题之前,要仔细理解课题要求。
我在此次课程设计中犯的最严重的错误,应该算没有仔细审题。
课题的要求是用读取文件的方式输入需要编码字符,译码所需的编码代号也要用文本方式输入。
我在拿到这个课题的时候,因为没有仔细理解这些要求,就采用了键盘输入字符进行编码和译码的方式,以致没有完全达到课题的要求。
另外,这次课程设计充分暴露了我的惰性思想。
在拿到这个课题后,因为对哈夫曼编码这个知识点理解比较到位,所以没花多少时间就完成了课题要求实现的功能。
然而,在此之后,我由于自我感觉良好和惰性,没有积极地去寻找改进程序的方法,也没对程序运行的界面进行美化,使其拥有良好的用户使用体验。
最终在考核的时候,交给老师的是一个界面简陋,功能不全面的程序。
通过这次课程设计,我更加深入了理解了哈夫曼编码的过程,以及利用哈夫曼编码对数据进行压缩的优越性,并且使我能够更熟练地运用树形的数据结构。
并且体会到了在学习中,要严格要求自己,不能因为一点点的成功就骄傲自满,停止不前。
附录:程序代码#include <iostream.h>#include<fstream.h>#include <string.h>#include <malloc.h>#include <stdio.h>const int Lengh=1000; //最大长度为1000char coding[100]; //存储二进制字符串int n; //定义全局变量ofstream file1("编码.txt");; //创建编码保存文件ofstream file2("译码.txt");; //创建译码保存文件enum Child{none,lchild,rchild}; //采用枚举标记事左孩子还是右孩子class element{public:elememt();void change(char l,char *c,int p,Child h,int w){code=c;letter=l;a=h;weight=w;parent=p;}void getparent(int p){parent=p;}void geta(Child h){a=h;}void getweight(int w){weight=w;}int returnweight(){return weight;}friend void Select(element h[],int k,int *a,int *b);friend void HuffmanTreeCode(element HT[]);friend void HuffmanTreeYima(element huff[],char cod[],int b);private:char letter,*code; //letter为字符,*code指向编码字符串int weight; //权值域int parent; //父结点序号Child a; //为父结点的左孩子还是右孩子};void Select(element h[],int k,int *a,int *b);//寻找最小和次小节点的序号void InitHuffmanTree(element huffTree[],char t[],int w[]) //哈夫曼树的初始化{int i,m=2*n-1,s1,s2; //no+n2=n 所以一要申请m个空间for(i=0;i<n;i++) //初始前n个结点{huffTree[i].change(t[i],'\0',-1,none,w[i]);}for(;i<=m;i++) //后m-n个结点置空{huffTree[i].change(' ','\0',-1,none,0);}for(i=n;i<m;i++) //建立哈夫曼树{Select(huffTree,i-1,&s1,&s2); //在huffTree中找权值最小的两个结点s1,s2huffTree[s1].getparent(i); //将s1,s2合并,则s1,s2的双亲是ihuffTree[s2].getparent(i);huffTree[s1].geta(lchild); //s1是左孩子huffTree[s2].geta(rchild); //s2是右孩子huffTree[i].getweight(huffTree[s1].returnweight()+huffTree[s2].returnweight ());//s1,s2的双亲的权值为s1,s2权值之和}}void Select(element h[],int k,int *a,int *b) //寻找最小和次小节点的序号{int i;int min1=1000; //初始化最小结点和次小结点int min2=1000;for (i=0;i<=k;i++)//找最小的结点序号{if (h[i].parent==-1&&h[i].weight<min1) //如果没有父结点并且它的权值小于min1的权值{*a=i; //将i放入a中min1=h[i].weight; //找到第一个最小结点}}for(i=0;i<=k;i++) //找次小结点的序号{if(h[i].parent==-1&&(*a!=i)&&h[i].weight<min2) //满足没有父结点,此序号不等于最小结点的序号,权值小于min2{*b=i;min2=h[i].weight; //找到次最小结点}}}void HuffmanTreeCode(element HT[]) //字符编码{int i;char *temp;temp=(char *)malloc(n*sizeof(char)); //分配n个字符空间temp[n-1]='\0'; //最后一个字符以后结束字符串int p;int s;for(i=0;i<n;i++) //n个字符结点一个个处理{p=i;s=n-1; //s为最后一个结点while(HT[p].parent!=-1) //从字符结点回溯,直至根结点{if(HT[p].a==lchild) //p指向的如果是左孩子temp[--s]='0'; //s位置字符为0else if(HT[p].a==rchild) //p指向的如果是右孩子temp[--s]='1'; //s位置字符为1p=HT[p].parent; //回溯父结点}HT[i].code=(char *)malloc((n-s)*sizeof(char));//分配结点编码长度的内存空间strcpy(HT[i].code,temp+s); //将temp中从第s个位置开始,将编码拷贝到 HT[i].codeprintf("%c",HT[i].letter);printf(": ");printf("%s\n",HT[i].code); //打印出字符即对应的二进制字符串file1<<HT[i].letter <<":"<<HT[i].code <<endl; //保存至编码文件中}}void HuffmanTreeYima(element huff[],char cod[],int b) //译码{char sen[100];char temp[50];char voidstr[]=" "; //空白字符串int t=0; int s=0;int xx=0;for(int i=0 ; i<b; i++){temp[t++]=cod[i]; //读取字符temp[t] = '\0'; //有效字符串for(int j=0;j<n;j++) //依次与所有字符编码开始匹配{if (!strcmp(huff[j].code,temp)) //匹配成功{sen[s]=huff[j].letter; //将字符保存到sen中s++;xx+=t;strcpy(temp,voidstr); //将TEMP置空t=0; //t置空break;}}}if(t==0) //t如果被置空了,表示都匹配出来了,打印译码{sen[s]='\0';cout<<"译码为:"<<endl;file2<<sen;cout<<sen<<endl;}else //t如果没有被置空,源码无法被完全匹配{ cout<<"二进制源码有错!从第"<<xx+1<<"位开始"<<endl;file2<<"二进制源码有错!从第"<<xx+1<<"位开始"<<endl;}}void main(){char a[Lengh],p;int i,b[Lengh];int symbol=1;int x;int k;if(!file1){cout<<"不能打开文件1!";return;}if(!file2){cout<<"不能打开文件2!";return;}cout<<"\t\t\t\t哈夫曼编码与译码\t\t\t\t"<<endl;cout<<"编码:"<<endl;cout<<"请输入一句话进行初始编码:";char buff[1024]={0};//零时存放输入的话cin.getline(buff,1024);//读入一行包括空格键,以回车键结束int len=strlen(buff);element h[Lengh];for (i=0;i<len;i++){for(int j=0;j<n;j++){if (a[j]==buff[i]){b[j]=b[j]+1;break;}}if (j>=n){a[n]=buff[i];b[n]=1;n++;}}for (i=0;i<n;i++){cout<<"字符:"<<(char)a[i]<<" 权值:"<<(int)b[i]<<endl;//a[]存字符 b[]存权值;}InitHuffmanTree(h,a,b); //哈夫曼树的初始化HuffmanTreeCode(h); //编码cout<<"译码:"<<endl;while(1){cout<<"请输入要译码的二进制字符串,输入'#'结束:";file2<<"二进制字符串:";x=1;k=0;symbol=1;while(symbol){cin>>p;if(p!='1'&&p!='0'&&p!='#') //若存在其它字符,x设为0,表示输入的不是二进制{x=0;}coding[k]=p;if(p=='#')symbol=0; //#号结束标志elsefile2<<p;k++;}if(x==1){file2<<endl<<"译码为:";HuffmanTreeYima(h,coding,k-1); //进行译码file2<<endl;}else{cout<<"有非法字符!"<<endl;file2<<endl<<"有非法字符!"<<endl;}cout<<"是否继续?(Y/N):";cin>>p;if(p=='y'||p=='Y')continue;elsebreak;}();();}。