哈夫曼编码与译码实现

合集下载

哈夫曼编码译码的设计与实现.pptx

abort();
} for(i=0;i<2*n-1;i++) //将内存中从 HaffNode[i]地址开始的 sizeof(HaffNode[i])的内容写入文件中
cout<<HaffNode[i].weight<<" ";
cout<<HaffNode[i].lchild<<" ";
cout<<HaffNode[i].rchild<<" ";
cout<<HaffNode[i].parent<<endl;
} //写入文件 fstream outfile1;
3
数据结构课程设计报告
第 4 页共 23 页
outfile1.open("E:\\nodedata.dat",ios::out|ios::trunc|ios::binary);//建立进行写入的文件
if(!outfile1) //没有创建成功则显示相应信息
{ cout<<"nodedata.dat 文件不能打开"<<endl;
二、系统设计
构造哈夫曼树时，使用静态链表作为哈夫曼树的存储。在构造哈夫曼树时，设计一个结构体数组 HuffNode 保存哈夫曼树中各结点的信息，根据二叉树的性质可知，具有 n 个叶子结点的哈夫曼树共有 2n-1 个结点，所以数组 HuffNode 的大小设置为 2n-1，求哈夫曼编码时使用一维结构数组HuffCode 作为哈夫曼编码信息的存储。求哈夫曼编码实际上就是在已建立的哈夫曼树中，从叶子结点开始，沿结点的双亲链域回退到根结点，每回退一步，就走过了哈夫曼的一个分支，从而得到一位哈夫曼编码值。由于一个字符的哈夫曼编码就是从根结点到相应叶子结点所经过的路径上各分支所组成的 0、1 序列，因此先得到的分支代码为所求编码的低位码，后得到的分支代码为所求的高位码 1、初始化功能模块此功能模块的功能为从键盘接受字符集大小n，以及n 个字符和 n 个权值。 2、建立哈夫曼编码的功能模块此模块功能为使用 1 中得到的数据按照教材中的构造哈弗曼的算法构造哈弗曼树，即将 HuffNode 数组中的各个位置的各个域都填上相关的值，并将这个结构体数组存于文件 nodedata.dat 中。函数原型为： void Creat_Haffmantree(int &n) {

哈夫曼编码和译码的设计与实现

算法与数据结构课程设计哈夫曼编码和译码的设计与实现1。

问题描述利用哈夫曼编码进行通信可以大大提高信道的利用率,缩短信息传输时间，降低传输成本。

但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。

对于双工信道(即可以双向传输信息的信道)，每端都需要一个完整的编/译码系统。

试为这样的信息收发站设计一个哈夫曼码的编/译码系统。

2。

基本要求a。

编/译码系统应具有以下功能:(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中.b。

测试数据（1）利用下面这道题中的数据调试程序.某系统在通信联络中只可能出现八种字符，其概率分别为0。

25，0.29,0。

07，0.08，0.14,0。

23，0。

03，0。

11，试设计哈夫曼编码。

（2)用下表给出的字符集和频度的实际统计数据建立哈夫曼树，并实现以下报文的编码和译码：“THIS PROGRAM IS MY FAVORITE".字符空格 A B C D E F G H I J K L M 频度 186 64 13 22 32 103 21 15 47 57 1 5 32 20字符 N O P Q R S T U V W X Y Z频度57 63 15 1 48 51 80 23 8 18 1 16 13．需求分析3。

数据结构哈夫曼树编码及译码的实现实验报告

实验：哈夫曼树编码及译码的实现一．实验题目给定字符集的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这就走向该结点的右结点，重复上面步骤。

哈夫曼编码和译码

11
哈夫曼树的构造算法: 哈夫曼树的构造算法: 个结点的一维数组, (1)初始化哈夫曼树的 )初始化哈夫曼树的2n-1个结点的一维数组, 个结点的一维数组即将各结点中的各个域均置0; 即将各结点中的各个域均置 ; 个权值存放到一维数组的前n个单元中 (2)读入个权值存放到一维数组的前个单元中, )读入n个权值存放到一维数组的前个单元中, 它们即为初始森林中的n个只含根结点的权值个只含根结点的权值; 它们即为初始森林中的个只含根结点的权值; (3)对森林中的二叉树进行合并,产生个新 )对森林中的二叉树进行合并,产生n-1个新结点,依次存放到一维数组的第n+1个开始的单元中, 个开始的单元中, 结点,依次存放到一维数组的第个开始的单元中在这个过程中要注意对每个结点双亲域, 在这个过程中要注意对每个结点双亲域,左右孩子域以及权值的修改. 域以及权值的修改.
13
s1=maxval;s2= maxval;/ 设maxval为float类型最大值 ; ;/*设 ;/ 为类型最大值 */ for(j =1;j<=i;j+ +) ( ; ; ) if (ht[j].parent = =0) /*判断是否为根结点判断是否为根结点*/ 判断是否为根结点 if (ht[j].weight<s1) { s2=s1;s1= ht[j].weight; p2=p1;p1=j; } ; ; ; ; else if (ht[j].weight <s2) { s2= ht[j].weight; p2=j; } ; ; ht[p1].parent=i;ht[p2].parent=i; ; ; ht[i].lchild =p1;ht[i].rchild=p2; ; ; ht[i].weight= ht[pl].weight+ht[p2].weight; ; } return (ht);} ;

哈夫曼编码译码代码

哈夫曼编码译码代码哈夫曼编码（Huffman Coding）是一种用于数据压缩的编码方法，通过对出现频率较高的字符使用较短的码字，对出现频率较低的字符使用较长的码字，从而实现数据的有效压缩。

以下是一个使用Java 实现哈夫曼编码和解码的示例代码：```javaimport java.util.ArrayList;import java.util.List;import java.util.PriorityQueue;public class HuffmanCoding {public static void main(String[] args) {String inputString = "This is a sample string";String encodedString = encode(inputString);String decodedString = decode(encodedString);System.out.println("Encoded String: " +encodedString);System.out.println("Decoded String: " + decodedString);}// 哈夫曼编码方法public static String encode(String inputString) {List<Character> characters = new ArrayList<>();List<Integer> frequencies = new ArrayList<>();for (char character : inputString.toCharArray()) {if (!characters.contains(character)) {characters.add(character);frequencies.add(1);} else {int index = characters.indexOf(character);frequencies.set(index, frequencies.get(index) + 1);}}// 创建最小堆，用于存储字符和频率PriorityQueue<CharacterFrequency> minHeap = new PriorityQueue<>();for (int i = 0; i < characters.size(); i++) {minHeap.add(new CharacterFrequency(characters.get(i), frequencies.get(i)));}// 构建哈夫曼树while (minHeap.size() > 1) {CharacterFrequency characterFrequency1 = minHeap.poll();CharacterFrequency characterFrequency2 = minHeap.poll();CharacterFrequency combinedCharacterFrequency = new CharacterFrequency(null,characterFrequency1.frequency + characterFrequency2.frequency);combinedCharacterFrequency.left = characterFrequency1;combinedCharacterFrequency.right = characterFrequency2;minHeap.add(combinedCharacterFrequency);}// 从根节点开始遍历哈夫曼树，生成编码StringBuilder encodedString = new StringBuilder();CharacterFrequency root = minHeap.poll();generateEncoding(root, encodedString);return encodedString.toString();}// 生成编码的辅助方法private static voidgenerateEncoding(CharacterFrequency characterFrequency, StringBuilder encodedString) {if (characterFrequency.left != null) {encodedString.append('0');generateEncoding(characterFrequency.left, encodedString);}if (characterFrequency.right != null) {encodedString.append('1');generateEncoding(characterFrequency.right, encodedString);}if (characterFrequency.character != null) {encodedString.append(characterFrequency.character);}}// 哈夫曼解码方法public static String decode(String encodedString) {List<Character> characters = new ArrayList<>();StringBuilder decodedString = new StringBuilder();int index = 0;while (index < encodedString.length()) {char c = encodedString.charAt(index);if (c == '0') {index++;CharacterFrequency characterFrequency = decodeNode(index, encodedString);characters.add(characterFrequency.character);} else if (c == '1') {index++;CharacterFrequency characterFrequency = decodeNode(index, encodedString);characters.add(characterFrequency.character);} else {characters.add(c);}}for (char character : characters.toCharArray()) {decodedString.append(character);}return decodedString.toString();}// 解码节点的辅助方法private static CharacterFrequency decodeNode(int index, String encodedString) {int numZeros = 0;while (encodedString.charAt(index) == '0') {numZeros++;index++;}int numOnes = 0;while (encodedString.charAt(index) == '1') {index++;}index--;CharacterFrequency characterFrequency = new CharacterFrequency(null,numZeros * numOnes);if (numZeros > 0) {characterFrequency.left = decodeNode(index - 1, encodedString);}if (numOnes > 0) {characterFrequency.right = decodeNode(index - 1, encodedString);}return characterFrequency;}// 字符频率类private static class CharacterFrequency {Character character;int frequency;CharacterFrequency left;CharacterFrequency right;public CharacterFrequency(Character character, int frequency) {this.character = character;this.frequency = frequency;}}// 字符频率比较器，用于构建最小堆private static class CharacterFrequencyComparator implements Comparator<CharacterFrequency> {@Overridepublic int compare(CharacterFrequencycharacterFrequency1, CharacterFrequency characterFrequency2) {return characterFrequency1.frequency - characterFrequency2.frequency;}}}```这段代码实现了哈夫曼编码和解码的功能。

哈夫曼编译码的设计与实现

哈夫曼编\译码的设计与实现一、简介1．设计目的：通过对简单哈夫曼编/译码系统的设计与实现来熟练掌握树型结构在实际问题中的应用。

2．问题的描述：利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。

但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码。

系统应该具有如下的几个功能：接收原始数据、编码、译码、打印编码规则。

二、数据结构的设计：1.哈夫曼结点结构体：typedef struct HtNode{int weight;int parent, lchild, rchild;}HtNode;2.哈夫曼树结构体：typedef struct HtTree{struct HtNode ht[MAXNODE+1];int root;}HtTree, *PHtTree;三、功能（函数）设计：总体上划分为四个模块，具体功能描述如下：1．初始化功能模块：接收输入信息，并正确输出2．建立哈夫曼树的功能模块：按照构造哈夫曼树的算法构造哈夫曼树，将HuffNode数组中的各个位置的各个域都添上相关的值3．哈夫曼编码的功能模块：根据输入的相关字符信息进行哈夫曼编码，然后将结果存入，同时将字符与0、1代码串的一一对应关系打印到屏幕上。

4．译码的功能模块：接收需要译码的0、1代码串，按照哈夫曼编码规则将其翻译成字符集中的字符所组成的字符串形式，将翻译的结果在屏幕上输出四、界面设计：该界面操做简单，内容详细，便于程序使用者根据提示轻松上手。

简洁明朗是该界面最大的特点。

哈夫曼编/译码请逐个输入结点和结点的权值>>>按Enter键开始根据此提示界面进入程序使用阶段。

请输入结点个数：根据用户输入结点个数，动态输入并存储字符及权值然后输出字符与0、1代码串的对应关系。

进入以下界面，进行后续操作1----------------------------编码2----------------------------译码3----------------------------重新输入权值;0----------------------------退出用户键入“0”，即可出编码译码操作五、程序设计：1．函数功能说明及其程序流程图的描述：1>:main函数：控制整个程序的整个流程。

哈夫曼码编、译码器的实现

根据下面给出的存储结构定义 typedef struct // 定义哈夫曼树中每个结点结构体类型 { char ch; //结点字符信息 int weight; // 定义一个整型权值变量 int lchild; // 定义左、右孩子及双亲指针 int rchild; int parent; } HTNode; typedef HTNode HFMT[MAXLEN]; //用户自定义HFMT数组类型 typedef char** HfCode;//动态分配字符数组存储哈夫曼编码表（7）基本操作的函数设计 void InitHFMT(HFMT T)；//初始化哈夫曼树 void InputWeight(HFMT T,char* weightFile)；// 输入权值 void SelectMin(HFMT T,int i,int *p1,int *p2)； //选择所有结点中较小的结点 void CreatHFMT(HFMT T)；// 构造哈夫曼树，T[2*n-1]为其根结点 void PrintHFMT (HFMT T)；// 输出向量状态表 void printHfCode(HfCode hc)；//输出字符的哈夫曼编码序列 HfCode hfEnCoding(HFMT T)；//利用构成的哈夫曼树生成字符的编码 void print_HuffmanTree(HFMT HT,int t,int i)//按树形形态输出哈夫曼树的形态 void Encoder(char* original,char* codeFile,HfCode hc,HFMT HT)； //利用已建好的哈夫曼树,对original文件中要传输的原始数据进行编码， //将编码结果存入文件codeFile中 void Decoder(char* codeFile ,char* textFile,HFMT HT)； //利用已建好的哈夫曼树,对传输到达的codeFile中的数据代码进行译

哈夫曼编码和译码的算法设计与实现

哈夫曼编码和译码的算法设计与实现实验名称哈夫曼编码和译码的算法设计与实现实验方案实验成绩实验日期实验室信息系统设计与仿真室I 实验操作实验台号班级姓名实验结果一、实验目的1、掌握哈夫曼编码的二叉树结构表示方法；2、编程实现哈夫曼编码译码器；3、掌握贪心算法的设计策略。

二、实验任务①从文件中读取数据，构建哈夫曼树；②利用哈夫曼树，对输入明文进行哈夫曼编码；③利用哈夫曼树，对输入编码译码为明文。

三、实验设计方案1、结构体设计Huffman树：包括字符，权，父亲下标，左孩子下标，右孩子下标#define N 29 //26个小写字母，逗号，句号和空格字符.struct treenode{ //静态链表char c; //charint w; //weightint f; //fatherint l; //left child indexint r; //right child index};struct treenode htree[2*N-1];2、自定义函数设计①函数原型声明void input(); //读取文件字符、权值数据void huffman(); //建立huffman树void getcode(int i, char *str); //得到单个字符的huffman编码void encode(char ch); //将明文进行huffman编码void decode(char *str); //将huffman编码译为明文②读取文件字符、权值数据void input(){int i;char c;int f;freopen("in.txt","r",stdin);for(i=0;i<n;i++)< p="">{c=getchar(); //接收字符scanf("%d",&f); //接收权值getchar(); //接收回车ht[i].c=c;ht[i].w=f;ht[i].l=ht[i].f=ht[i].r=-1; //初始化父亲、左右孩子下标} freopen( "CON", "r", stdin);}③建立huffman树//使用贪心法建立huffman树,每次选择权值最小的根结点void huffman(){void huffman(){int j,k,n;input();j=0;k=N;for(n=N;n<2*N-1;n++){ //建立huffman树，共合并N-1次int r=0,s=0;ht[n].l=ht[n].f=ht[n].r=-1;while(r<2){ //选择两个最小的权值结点if((ht[k].w==0 || ht[k].w>ht[j].w) && j<n){< p="">s+=ht[j].w;if(r==0) ht[n].l = j; //修改父亲、孩子下标else ht[n].r=j;ht[j].f=n;j++;}else{s+=ht[k].w;if(r==0) ht[n].l = k; //修改父亲、孩子下标else ht[n].r=k;ht[k].f=n;k++;}r++;}ht[n].w=s; //修改权值}}④根据字符下标找到字符的huffman编码//根据字符所在的下标，从叶子结点往上搜索到根节点，然后逆置得到该字符的huffman编码void getcode(int i, char *str){ int n,j,l=0;for(n=i;ht[n].f!=-1;n=ht[n].f){ //沿着父亲往上搜索int m=ht[n].f;if(n==ht[m].l)str[l++]='0'; //左孩子记为0elsestr[l++]='1'; //右孩子记为1}for(j=0;j<=(l-1)/2;j++){ //将编码逆置char t;t=str[j];str[j]=str[l-1-j];str[l-1-j]=t;}str[l]=0; // str存放huffman编码，字符串结束标记}⑤读入明文生成huffman编码void encode(char ch){int i;char str[N];for(i=0;ht[i].c!=0;i++)if(ht[i].c==ch) //找字符下标break;if (ht[i].c!=0){getcode(i,str); //得到字符的huffman编码printf("%s",str);}}⑥将huffman编码串译码为明文void decode(char *str){while(*str!='\0'){int i;for(i=2*N-2;ht[i].l!=-1;){if(*str=='0')i=ht[i].l;elsei=ht[i].r;str++;}printf("%c",ht[i].c);}}3、主函数设计思路：主函数实现实验任务的基本流程。

哈弗曼编码译码器的实现

“数据结构”课程设计报告（哈夫曼编码/译码器的实现）学生姓名：_指导教师：_______所在系：电子信息系__所学专业：计算机科学与技术_年级：目录1、需求分析 (2)1.1课程设计要求 (2)1.2选题的意义及背景 (2)1.3本组课程设计目标 (2)2、概要分析 (3)2.1输出哈夫曼树 (3)2.2哈夫曼编码 (3)2.3哈夫曼译码 (4)3、详细设计 (5)3．1哈夫曼建树 (5)3.2哈夫曼编码 (5)3.3哈夫曼译码 (5)3.4主函数 (6)4、调试分析 (6)4.1输入要压缩的文件 (6)4.2读文件并计算字符频率 (7)4.3根据字符的频率，利用Huffman编码思想创建Huffman树 (7)4.4由创建的Huffman树来决定字符对应的编码，进行文件的压缩 (7)4.5解码压缩即根据Huffman树进行译码 (7)5、用户手册 (9)6、测试结果 (10)7、总结 (11)8、参考文献 (12)9、小组人员分工 (12)1、需求分析1.1课程设计要求基于哈夫曼编码的思想进行文件的压缩处理(1) 能够将一个文件进行编码压缩(2) 能够将压缩的文件解码还原1.2选题的意义及背景锻炼我们的编码能力，真正理解数据结构的编码思想,并且锻炼我们的动手能力和成员间的配合，提高程序编写能力。

在信息传递时，希望长度能尽可能短，即采用最短码。

赫夫曼编码的应用，就是采用这种有效的数据压缩技术可以节省数据文件的存储空间和计算机网络的传送时间。

1.3本组课程设计目标实现赫夫曼树的建立，赫夫曼编码的对对应的文件进压缩和对压缩文件的进行译码。

调试程序，最后完成程序设计，完成设计报告，总结经验。

2、概要分析主要模块及调用关系2.1输出哈夫曼树求字符结点数const unsigned int n=256; //字符数const unsigned int m=256*2-1; //结点总数用类编码哈夫曼树class HuffmanTree{ //Huffman树public:void Code(); //编码 void UnCode(); //译码private:HTNode HT[m+1]; //树结点表(HT[1]到HT[m])char Leaf[n+1]; ｝; //叶结点对应字符(leaf[1]到leaf[n])2.2哈夫曼编码char *HuffmanCode[n+1]; //叶结点对应编码(*HuffmanCode[1]到*HuffmanCode[n])unsigned int count; //频度大于零的字符数unsigned int char_index[n]; //字符对应在树结点表的下标(char_index[0]到char_index[n-1])unsigned long size; //被压缩文件长度FILE *infp,*outfp; //输入/出文件Buffer buf; //字符缓冲void Stat();//统计字符出现频度并过滤掉频度为零的字符//在HT[0]~HT[k]中选择parent为-1，树值最小的两个结点s1,s2 void Select(unsigned int k, unsigned int &s1, unsigned int &s2);void Write(unsigned int bit); //向outfp中写入一个比特void Write(unsigned int num,unsigned int k);//向outfp中写入k个比特void WriteToOutfp(); //强行写入outfpint NToBits(unsigned int num);//0~num之间的整数用二进位表示所需的最少位数2.3哈夫曼译码void Read(unsigned int &bit); //从infp中读出一个比特void Read(unsigned int &num,unsigned int k);//从infp中读出k个比特int NToBits(unsigned int num);//0~num之间的整数用二进位表示所需的最少位数void CreateFromCodeFile(); //由编码文件中存储的树结构建立Huffman树void CreateFromSourceFile();//由被压缩文件建立Huffman树,将树结构存入编码文//件的文件头部中,并求每个字符的Huffman编码3、详细设计3．1哈夫曼建树统计字符得出结果字符的权值，然后建立对应的哈夫曼树。

实验二哈夫曼树及哈夫曼编码译码的实现

实验二哈夫曼树及哈夫曼编码译码的实现实验二:哈夫曼树及哈夫曼编码译码的实现(验证性、4学时) 一、实验目的和要求构建哈夫曼树及哈夫曼编码，输出哈夫曼树及哈夫曼编码，完成编码与译码的算法。

(1)掌握树的有关操作算法2)熟悉树的基本存储方法 ((3)学习利用树求解实际问题二、实验内容和原理定义哈夫曼树的存储结构;输入要编码的字符权重，根据权重建立哈夫曼树，并进行编码，最后输出哈夫曼编码。

三、实验环境硬件:(1)学生用微机(2)多媒体教室或远程教学(3)局域网环境软件:(1)Windows XP中文操作系统 (2)Turbo C 3.0 四、算法描述及实验步骤1( 算法描述(1) 建立叶子结点——由于每个叶子结点都有一个权重值，构造哈夫曼树的过程中每个分枝节点的权重值等于两个孩子结点权重值的和，所以应该有一个权重域和指向左右孩子的两个指针域;(2) 另外在建成哈夫曼树之后，为了求得每个叶子结点的哈夫曼编码，需要走一条从叶子结点到根结点的路径，而译码的过程是从根结点出发到叶子的不断匹配的过程，所以既需要知道孩子结点的信息，也需要知道双亲结点的信息，应该再有一个指向双亲结点的指针域。

(3) 构建哈夫曼编码——在已建好的哈夫曼树中从每个叶子结点开始沿双亲链域回退到根结点，每回退一步走过哈夫曼树的一个分枝得到一个哈夫曼编码值;由于每个叶子结点的哈夫曼编码是从根就诶点到相应叶子结点的路径上各分枝代码所组成的0、1序列，所以先得到的分枝代码为说求编码的低位码而后得到的为高位码。

2( 算法流程图构建哈夫曼树算法流程哈夫曼编码算法流程3( 代码#include<stdio.h>#define maxvalue 10000//定义最大权值常量#define maxnodenumber 100//定义结点最大数目常量 typedef struct{int weight;int parent,lchild,rchild; }htnode;typedef htnode *huffmantree;//定义哈夫曼树类型 htnodeht[maxnodenumber]; //定义静态三叉链表存储区数组#define maxbit 10//定义哈夫曼编码的最大长度 typedef struct//定义保存一个叶子结点哈夫曼编码的结构 {int bit[maxbit];//哈夫曼编码域为一维数组int start;//开始位置域为整型}hcodetype;//定义哈夫曼编码类型hcodetype cd[maxnodenumber];//定义存放哈夫曼编码的数组cd void crthuffmantree(int n);//建立哈夫曼树void gethuffmancode(int n);//哈夫曼编码void main (){int nodenum;printf("inputnodenum:"); scanf("%d",&nodenum);crthuffmantree(nodenum); gethuffmancode(nodenum); }void crthuffmantree(int n)//该算法对n个叶子结点建立哈夫曼树，权重值由键盘逐个输入{int i,j,m1,m2,k1,k2;//定义局部变量for(i=0;i<2*n-1;i++)//数组ht初始化{ht[i].weight=0;//权重初始化为0ht[i].parent=-1;//3个指针域初始化为-1，即NULL ht[i].lchild=-1;ht[i].rchild=-1;}for (i=0;i<n;i++)//读入n个叶子结点的权重值scanf("%d",&ht[i].weight); for(i=0;i<n-1;i++)//控制n-1趟生成新结点构造哈夫曼树 {m1=maxvalue;//预置最小权值变量为最大权值 m2=maxvalue;//预置次小权值变量为最大权值 k1=0;k2=0;//预置最小和次小权值结点位置为下标0处for (j=0;j<n+i;j++)//控制一趟中找处最小权值的结点if(ht[j].parent==-1&&ht[j].weight<m1){m2=m1;k2=k1;//若第j个结点权小于当前最小的m1改为次小的m1=ht[j].weight;k1=j;//并记下新的当前最小权值及位置}elseif(ht[j].parent==-1&&ht[j].weight<m2){m2=ht[j].weight;k2=j;}//否则若小于当前次小的m2则更新m2及其位置ht[k1].parent=n+i;//修改最小权值结点的双亲为刚生成的新结点ht[k2].parent=n+i;//修改次小权值结点的双亲刚好生成的新结点ht[n+i].weight=ht[k1].weight+ht[k2].weight;//填新生成结点的权重值ht[n+i].lchild=k1;//新生成结点的左孩子指针指向k1ht[n+i].rchild=k2;//新生成结点的右孩子指针指向k2}}void gethuffmancode(int n) /*对具有n个叶子结点的哈夫曼树ht,求所有叶子结点的哈夫曼编码并输出*/{int i,j,c,p; /*定义局部变量*/for(i=0;i<n;i++) /*定义存放哈夫曼编码的数组cd*/ {c=i;j=maxbit; /*为求一个结点的哈夫曼编码初始化c和j*/ do{j--; /*j指向bit中存放编码位的正确位置*/ p=ht[c].parent; /*p指向c 的双亲结点*/if(ht[p].lchild==c) /*如果c是p的左孩子*/cd[i].bit[j]=0; /*编码位上赋0*/elsecd[i].bit[j]=1; /*否则c是p的右孩子，编码位上赋1*/ c=p; /*更新c为p,为求下一个编码位做准备*/ }while(ht[p].parent!=-1); /*当未到达根结点继续做do循环*/ cd[i].start=j; /*求完一个叶子结点的哈夫曼编码时，记下编码开始位置*/}for(i=0;i<n;i++) /*输出n个叶子结点的哈夫曼编码*/{for(j=cd[i].start;j<maxbit;j++) /*逐位输出一个编码*/printf("%d",cd[i].bit[j]);printf("\n"); /*输出完一个哈夫曼编码后换行*/ }}五、调试过程一次编译二次编译三次编译六、实验结果七、总结(1) 深刻体会构建哈夫曼树的整个过程，对整体有个总的理解; (2) 复习以前所学C语言的一些语法，例如:for循环，if循环，while循环 (3) 理解哈夫曼的编码过程，编码思想(4) 此程序的不足之处在于在进行哈夫曼编码时未能对字符进行编制，有待改进。

哈夫曼编码译码器实验报告

哈夫曼编码译码器实验报告实验名称：哈夫曼编码译码器实验一、实验目的：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.比较编码前后字符串的内容，结果正确。

五、实验总结：通过本次实验，我了解了哈夫曼编码的原理和应用，并且实现了一个简单的哈夫曼编码的编码和译码器。

在实验过程中，我充分运用了数据结构中的树的知识，构建了一个哈夫曼树，并生成了编码表。

通过编码和译码过程，我进一步巩固了对树的遍历和节点查找的理解。

实验结果表明，本次哈夫曼编码的编码和译码过程正确无误。

在实验的过程中，我发现哈夫曼编码对于频率较高的字符具有较短的编码，从而实现了对字符串的高效压缩。

同时，哈夫曼编码还可以应用于数据传输和存储中，提高数据的传输效率和存储空间的利用率。

通过本次实验，我不仅掌握了哈夫曼编码的编码和译码过程，还深入了解了其实现原理和应用场景，加深了对数据结构和算法的理解和应用能力。

实验五哈夫曼编码与译码的设计与实现

实验五哈夫曼编码与译码的设计与实现一、问题描述利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。

但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。

对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。

试为这样的信息收发编写一个哈夫曼码的编/译码系统。

基本要求：（1）接收原始数据：从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件nodedata.dat中。

（2）编码：利用已建好的哈夫曼树（如不在内存，则从文件nodedata.dat 中读入），对文件中的正文进行编码，然后将结果存入文件code.dat中。

（3）译码：利用已建好的哈夫曼树将文件code.dat中的代码进行译码，结果存入文件text中。

（4）打印编码规则：即字符与编码的一一对应关系。

（5）打印哈夫曼树：将已在内存中的哈夫曼树以直观的方式显示在终端上。

二、数据结构设计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序列，因此先得到的分支代码为所求编码的低位码，后得到的分支代码为所求的高位码。

哈夫曼编码和译码系统(附源代码)

实训报告题目：哈夫曼编码和译码系统院系：专业：姓名：学号：指导教师:日期:一.需求分析•二.概要设计(1)建立哈夫曼树、编码•(2)字符匹配•(3)哈夫曼树遍历• 3三.详细设计及编码实现•3四.流程图(1)总流程图75(2)编码实现流程图・16(3)译码实现流程图・17五.调试分析(1 )计算权值-18(1)生成哈夫曼树，建立编码表• 18 (3)将输入字符编码 19( 4 )输入新的字符串，进行译码 19( 5)输入新的二进制数将其译为字符 20六 . 系统维护 20 七．实验总结 20八. 源代码 21一．需求分析《1》问题描述：在传送电文时，人们总是希望传送时间尽可能短，这就是要求使电文代码长度尽可能短。

利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。

但是，这要求在发送端通过一个编码系统能够对待传输数据预先编码，在接收端将传来的数据进行译码。

对于双工信道（即可以双向传输信息的信道），每段都需要一个完整的编/译系统。

所以为这样的信息收发站写一个哈夫曼的编译码系统。

《2》打开一篇英文文章，统计该文章中每个字符出现的次数，然后以它们作为权值，对每一个字符进行编码，编码完成后再对其编码进行译码。

问题补充：1.从硬盘的一个文件里读出一段英语文章。

2.统计这篇文章中的每个字符出现的次数。

3.以字符出现字数作为权值，构建哈夫曼树，并将哈夫曼树的存储结构的初态和终态进行输出。

4.对每个字符进行编码并将所编码写入文件然后对所编码进行编译。

《3》这个哈夫曼编码译码主要是以英文字母输入进行编码与编译，编码译码过程由系统自动完成，人工操作部分就是电文的录入，和编译出来时的读操作。

．概要设计本程序主要用到了三个算法。

(1)哈夫曼树建立、编码在初始化(I)的过程中间，要用输入的字符和权值建立哈夫曼树并求得哈夫曼编码。

先将输入的字符和权值存放到一个结构体数组中，建立哈夫曼树，将计算所得的哈夫曼编码存储到另一个结构体数组中。

哈夫曼树、编码和译码的实现

{
creathfmt(t);
listBox1->Items->Clear();
String ^s,^s0=" ";
for(inti=0;i<2*n-1;i++)
{
if(i<10&&i>-1) s=i+": ";elses=i+" ";
if(t[i].parent<10&&t[i].parent>-1) s=s+" "; s=s+s0+t[i].parent;
日期：2013年12月29日
教务处制
了解哈夫曼树特点及有关概念，掌握哈夫曼树的各种基本操作算法思想及其实现。
1、初始化哈夫曼树
2、建立哈夫曼树
3、编码哈夫曼树
4、解码哈夫曼树
三、实验步骤
constintMAXLEN=100;
structhtnode
{
intweight,lchild,rchild,parent;
t[i].lchild=-1;
t[i].rchild=-1;
t[i].parent=-1;
}
}
voidselectmin(hfmt t,inti,int*p1,int*p2)
{
longmin1=999;
longmin2=999;
intj;
for(j=0;j<=i;j++)
if(t[j].parent==-1)
成绩教师签字
};
typedefhtnode hfmt[MAXLEN];
constintn=8;

数据结构哈夫曼编码译码c语言

数据结构哈夫曼编码译码c语言哈夫曼编码是一种经典的数据压缩算法。

这种算法可以根据数据中出现频率最高的字符生成一个种类较少的编码表，然后用这个编码表来对数据进行编码，从而达到压缩数据的效果。

哈夫曼编码的核心是生成编码表，生成编码表的过程包括以下几个步骤：1. 统计字符出现频率。

遍历一遍数据，统计每个字符出现的次数。

2. 创建哈夫曼树。

将每个字符出现的次数作为权值，构造一棵哈夫曼树。

构造哈夫曼树需要用到一种优先队列。

3. 生成编码表。

对哈夫曼树进行遍历，当遇到一个叶子节点时，将它的路径上的所有节点转换成一个编码，这个编码就是该节点代表的字符的哈夫曼编码。

4. 对数据进行编码。

按照编码表，将原始数据中的每个字符都替换成对应的哈夫曼编码，得到压缩数据。

哈夫曼编码的解码操作相对简单，只需要根据编码表将每个哈夫曼编码转换成它代表的字符，再将这些字符拼接起来就可以得到原始数据。

以下是C语言实现哈夫曼编码和译码的例子：```c#include <stdio.h>#include <stdlib.h>#include <string.h>#define MAX_NODE 100typedef struct node {char data;int freq;int parent, lchild, rchild;} Node;int nodes_num;Node* nodes;void build_huffman_tree() {int i, j, min1, min2;for (i = 0; i < nodes_num - 1; i++) {min1 = min2 = -1;for (j = 0; j < nodes_num + i; j++) {if (nodes[j].parent == -1) {if (min1 == -1 || nodes[j].freq < nodes[min1].freq) {min2 = min1;min1 = j;} else if (min2 == -1 || nodes[j].freq < nodes[min2].freq) { min2 = j;}}}nodes[min1].parent = nodes_num + i;nodes[min2].parent = nodes_num + i;nodes[nodes_num + i].lchild = min1;nodes[nodes_num + i].rchild = min2;nodes[nodes_num + i].freq = nodes[min1].freq + nodes[min2].freq;}}nodes_num = 0;nodes = (Node*)malloc(MAX_NODE * sizeof(Node));for (i = 0; i < MAX_NODE; i++) {nodes[i].freq = nodes[i].parent = -1;nodes[i].lchild = nodes[i].rchild = -1;}build_huffman_tree();codes_num = 0;codes = (Code*)malloc(nodes_num * sizeof(Code));printf("src: %s\n", src);return 0;}```上述代码中，我们使用结构体来表示哈夫曼树的节点，其中包括该节点的权值（即字符出现的次数）、父节点、左右孩子节点等信息。

数据结构课程设计哈夫曼编码译码器

题目一: 哈夫曼编码与译码一、任务设计一个运用哈夫曼算法的编码和译码系统, 反复地显示并解决以下项目, 直到选择退出为止。

规定：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．一个完整的系统应具有以下功能：1）初始化（Initialzation）。

从数据文件 DataFile.data 中读入字符及每个字符的权值，建立哈夫曼树HuffTree；2）编码（EnCoding）。

用已建好的哈夫曼树，对文件ToBeTran.data 中的文本进行编码形成报文，将报文写在文件 Code.txt 中；3）译码（Decoding）。

利用已建好的哈夫曼树，对文件CodeFile.data 中的代码进行解码形成原文，结果存入文件 Textfile.txt 中；4）输出（Output）。

输出 DataFile.data 中出现的字符以及各字符出现的频度（或概率）；输出 ToBeTran.data 及其报文 Code.txt；输出 CodeFile.data 及其原文 Textfile.txt；要求：所设计的系统应能在程序执行的过程中，根据实际情况（不同的输入）建立DataFile.data、ToBeTran.data 和 CodeFile.data 三个文件，以保证系统的通用性。

二、实验目的：理解哈夫曼树的特征及其应用；在对哈夫曼树进行理解的基础上，构造哈夫曼树，并用构造的哈夫曼树进行编码和译码；通过该实验，使学生对二叉树的构建、遍历等以及哈夫曼编码的应用有更深层次的理解。

实验步骤：实验分 2 次完成第 1 次：完成程序的主框架设计，进行调试，验证其正确性；（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）实现哈夫曼编码和译码算法。

哈夫曼编码译码

哈夫曼编码/译码一、实验内容利用哈夫曼编码进行住处通讯可以大大提高信道利用率,缩短住处传输时间,降低成本,但是,这要求在发送端通过一个编码系统将传输的数据预先编码,在接收端通过一个译码系统对传来的数据进行译码(复原),对于双向传输信息的信道,每端都一个完整的编码译码系统,试为这样的住处收发站写一个哈夫曼友的编码译码系统.测试数据：用下表给出的字符集和频度的计数据建立哈曼树,并实现以下报文的编码和译码：“THIS PROGRAM IS MY FA VORITE”.。

字符 A B C D E F G H I J K L M频数186 64 13 22 32 103 21 15 47 57 1 5 32 20字符N O P Q R S T U V W X Y Z频数57 63 15 1 48 51 80 23 8 18 1 16 1二、实验目的树型结构是一种应用极为广泛的非线性数据结构,也是本课程的重点内容,哈夫曼树(最优二叉树)是树型结构的典型应用,本次实验突出了数据结构加操作的程序设计观点,希望能根据树型结构的非线性特点,熟悉各种存储结构的特性,达到如何应用树型结构的非线性特点,熟悉各种存储结构的特性,达到如何应用树型结构解决具体问题的目的.三、实验步骤：1、需求分析1）、利用哈夫曼编码进行信息通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。

但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。

对于双工信道（既可以双向传输信息的信道），每端都需要一个完整的编/译码系统。

本次设计就是为这样的信息收发站写的一个哈夫曼的编/译码器。

本实验要求：2）、本演示程序中，用户可以输入键盘中的任意字符，长度为任意长，字符输入顺序不限，且允许出现重码3）、演示程序以用户与计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运算命令，相应的输入数据（可虑去输入中的非法字符）和运算结果显示在其后。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

数据结构课程设计评阅书2011—2012学年第一学期专业：信息管理与信息系统学号： 1021024016 姓名：万永馨课程设计名称：数据结构课程设计设计题目：哈夫曼编码与译码的实现完成期限：自 2012 年 2 月 20 日至 2012 年 3 月 2 日共 2 周设计依据、要求及主要内容（可另加附页）：该设计题目将按以下要求完成：哈夫曼编码与译码是信息传输中应用的经典算法，运用C或VC++结合数据结构等基础知识，按以下要求编程实现各种进制的转换。

任务要求：1）阐述设计思想,画出流程图;2）需要对哈夫曼编码/译码的相关原理有所了解，设计数据结构，建立必要的信息数据文件（最好存储成外部文件），并分析完成用户所需的基本操作功能；3）实现给定信息的编码和译码功能；4）应有较好的界面设计，说明程序测试方法；5）按照格式要求完成课程设计说明书。

设计要求:1）问题分析和任务定义：根据设计题目的要求，充分地分析和理解问题，明确问题要求做什么？（而不是怎么做？）限制条件是什么？确定问题的输入数据集合。

2）逻辑设计：对问题描述中涉及的操作对象定义相应的数据类型，并按照以数据结构为中心的原则划分模块，定义主程序模块和各抽象数据类型。

逻辑设计的结果应写出每个抽象数据类型的定义（包括数据结构的描述和每个基本操作的功能说明），各个主要模块的算法，并画出模块之间的调用关系图；3）详细设计：定义相应的存储结构并写出各函数的伪码算法。

在这个过程中，要综合考虑系统功能，使得系统结构清晰、合理、简单和易于调试，抽象数据类型的实现尽可能做到数据封装，基本操作的规格说明尽可能明确具体。

详细设计的结果是对数据结构和基本操作做出进一步的求精，写出数据存储结构的类型定义，写出函数形式的算法框架；4）程序编码：把详细设计的结果进一步求精为程序设计语言程序。

同时加入一些注解和断言，使程序中逻辑概念清楚；5）程序调试与测试：能够熟练掌握调试工具的各种功能，设计测试数据确保程序正确。

调试正确后，认真整理源程序及其注释，形成格式和风格良好的源程序清单和结果；6）结果分析：程序运行结果包括正确的输入及其输出结果和含有错误的输入及其输出结果。

算法的时间、空间复杂性分析；7）编写课程设计报告；以上要求前三个阶段的任务完成后，将设计说明书的草稿交指导老师面审，审查合格方可进入后续阶段的工作。

设计工作结束，经指导老师验收合格后将设计说明书装订，并答辩。

指导教师（签字）：教研室主任（签字）：批准日期：年月日摘要在当今信息爆炸时代，如何采取有效的数据压缩技术来节省数据文件的储存空间越来越引起人们的重视。

本次课程设计的实验题目为哈夫曼编码与译码的实现。

利用哈夫曼树求得的用于通讯的二进制编码称为哈弗曼编码。

通常我们将文字转化为二进制称为编码，而将二进制转化为文字称为译码。

此次程序就是将一个简单的文件进行编码转化为二进制数存入文件并进行译码进而输出。

而将文件转化为二进制编码运用哈夫曼树的相关知识可以有效的节省存储空间与时间。

关键词：哈夫曼树;哈夫曼树的编码;哈夫曼树的译码;哈夫曼树初始化;哈夫曼树的建立开发工具：visual C++目录1.引言 (6)2.课题描述 (7)3.程序设计 (8)3.1实验目的与基本要求 (8)3.2部分函数介绍 (8)3.3主要模块程序流程图 (9)4 系统实现 (13)4.1 主函数（菜单函数） (13)4.2 建立HuffmanTree (13)4.3生成Huffman编码并写入文件 (15)4.4对文件哈夫曼译码.txt 进行译码译码 (16)5 系统调试 (17)附录源程序 (23)1.引言在课程设计过程中，我们四个人一组选择一个课题，认真研究，根据课堂讲授内容，借助书本，自己动手实践。

这样不但有助于我们消化课堂所讲解的内容，还可以增强我们的独立思考能力和动手能力；通过编写实验代码和调试运行，我们可以逐步积累调试C程序的经验并逐渐培养我们的编程能力、用计算机解决实际问题的能力。

在课程设计过程中，我们不但有自己的独立思考，还借助各种参考文献来帮助我们完成系统。

更为重要的是，我们同学之间加强了交流，在对问题的认识方面可以交换不同的意见。

同时，师生之间的互动也随之改善，我们可以通过具体的实例来从老师那学到更多的实用的知识。

数据结构课程具有比较强的理论性，同时也具有较强的可应用性和实践性。

课程设计是一个重要的教学环节。

我们在一般情况下都能够重视实验环节，但是容易忽略实验的总结，忽略实验报告的撰写。

通过这次实验让我们明白：作为一名大学生必须严格训练分析总结能力、书面表达能力。

需要逐步培养书写科学实验报告以及科技论文的能力。

只有这样，我们的综合素质才会有好的提高。

2.课题描述课题：哈夫曼编码与译码的实现问题描述：对文件哈夫曼.txt中的字符串进行编译，统计其中的字符种类、个数作为权值。

1. 从D盘的数据结构课程设计文件夹中建立哈夫曼.txt文件里读出文章（必须大写）；2. 运用jsp函数统计这篇文章中的每个字符出现的次数；3. 以字符出现字数作为权值，构建哈夫曼树，并将哈夫曼树的存储结构的初态和终态进行输出；4. 对每个字符进行编码并将所编码写入程序，然后对另一文件中的编码编码进行破译。

具体介绍：在本课题中，我们在硬盘D盘中预先建立一个哈夫曼.txt 文档，在里面编辑一篇文章(大写)。

然后运行程序，调用()函数读出该文章，显示在界面；再调用jsq()函数对该文章的字符种类进行统计，并对每个字符的出现次数进行统计，并且在界面上显示；然后以每个字符出现次数作为权值，调用ChuffmanTree()函数构建哈夫曼树；并调用print1()和print2()函数将哈夫曼的存储结构的初态和终态进行输出。

然后哈夫曼树进行编码，再对另一文件哈夫曼译码.txt 编码进行译码，再输出至界面。

至此，整个工作就完成了。

3.程序设计3.1实验目的与基本要求利用赫夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。

这要求在发送端通过一个编码系统对待传输数据预先编码，在接收端将传来的数据进行译码（复原）。

对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。

试为这样的信息收发站编写一个赫夫曼码的编/译码系统。

一个完整的系统应具有以下功能：(1) 初始化（Initialization）。

从文件哈夫曼.txt 读入字符集,，统计字母个数作为权值，建立赫夫曼树。

(2) 编码（Encoding）。

利用已建好的赫夫曼树（如不在内存，则从文件中读入），对哈夫曼树进行编码，然后将结果存入文件哈夫曼译码.txt中。

(3) 译码（Decoding）。

利用已建好的赫夫曼树将文件哈夫曼译码.txt 中的代码进行译码3.2部分函数介绍①从硬盘读取字符串(参数)②建立HuffmanTree通过三个函数来实现：void select(参数)说明：在ht[1....k]中选择parent为0且权值最小的两个根结点的算法int jsq(参数)说明：统计字符串中各种字母的个数以及字符的种类void ChuffmanTree()说明：构造哈夫曼树③输出哈夫曼树的存储结构的初态和终态分别调用print1()和print2()来实现void print1(参数)说明：输出哈夫曼树的初态void print2(参数)说明：输出哈夫曼树的终态④哈夫曼编码和译码void HuffmanEncoding(参数)说明：哈夫曼编码char*decode(参数)说明：哈夫曼译码3.3主要模块程序流程图①主函数流程图：图 3.1流程图注释：图3.1比较简单，由该图可知主要是调用各个函数模块，首先代开已经存在的文件，然后统计总的字符数以及出现的各个字符和频率。

然后才开始建立哈夫曼树，接着在哈夫曼树的基础上对其进行编码，编码之后才是译码。

最后输出结束。

图 3.2流程图注释：图3.2是表示构造哈夫曼树的过程。

首先输入num个叶结点的权值，当i=num是循环结束。

然后进行哈夫曼树的构建，当i=2*num-1是循环结束。

最后输出所得到的字符统计情况。

③哈夫曼编码：图 3.3流程图3.3表示哈夫曼编码情况。

首先初始化，Cd[--start]=0,start=num。

然后从首地址开始进行比较，找节点的父母地址然后看节点为父母地址的左孩子是的话为’0’,反之为’1’.依次开始上溯。

将编码存入H[i].bits。

哈夫曼译码：图 3.4流程图3.4表示哈夫曼译码情况。

首先讲哈夫曼编码存入的文件打开，将哈夫曼编码导出。

然后将文件中读出的字符与哈夫曼编码cd进行比较strcmp(HC[j].bits,cd==0，相等的话开始译出str[k]=HC[j].ch。

4 系统实现各模块关键代码及算法的解释：4.1 主函数（菜单函数）主函数相对简单，只需了解顺序，依次调用即可。

这里不做解释4.2 建立HuffmanTree代码解释：该函数为在ht[1....k]中选择parent为0且权值最小的两个根结点的算法，其序号为s1和s2。

void select(HuffmanTree T,int k,int &s1,int &s2){int i,j;int min1=32767;for(i=1;i<=k;i++)if(T[i].weight<min1 &&T[i].parent==0){j=i;min1=T[i].weight;}s1=j;min1=32767;for (i=1;i<=k;i++)if(T[i].weight<min1 && T[i].parent==0 && i!=s1){j=i;min1=T[i].weight;}s2=j;}代码解释：下面函数用来统计字符串中各种字母的个数以及字符的种类。

当字符在A和z 之间时即被计数，并用str[j]保存字母到数组中，用cnt[j]统计每种字符个数。

j返回总共读取的字符数目。

int jsq(char *s,int cnt[],char str[]){int i,j,k;char *p;int temp[53];for(i=1;i<=52;i++)temp[i]=0;for(p=s; *p!='\0';p++){{if(*p>='A'&&*p<='z')k=*p-64;temp[k]++;}} //统计各种字符的个数for(i=1,j=0;i<=52;++i)if(temp[i]!=0 ){j++;str[j]=i+64; //送对应的字母到数组中cnt[j]=temp[i]; //存入对应字母的权值}return j; //j是输入字母总数}代码解释：下面函数用来构造哈夫曼树HT。