计算机体系结构实验-对指令操作码进行霍夫曼编码
霍夫曼编码设计实验报告
一、实验目的1. 理解霍夫曼编码的基本原理和算法流程。
2. 掌握霍夫曼编码的构建过程和编码方法。
3. 通过实验验证霍夫曼编码在数据压缩方面的效果。
4. 提高编程能力和数据结构应用能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验原理霍夫曼编码是一种基于字符出现频率进行编码的数据压缩方法。
其基本原理如下：1. 对字符进行统计，得到每个字符出现的频率。
2. 根据频率对字符进行排序，频率高的字符排在前面。
3. 构建霍夫曼树，将频率高的字符放在树的左侧，频率低的字符放在树的右侧。
4. 从树根到叶子节点，为每个字符分配一个二进制编码，频率高的字符用较短的编码表示，频率低的字符用较长的编码表示。
四、实验步骤1. 定义一个结构体HuffmanNode，用于存储字符及其频率。
2. 实现一个函数用于统计字符频率。
3. 实现一个函数用于构建霍夫曼树。
4. 实现一个函数用于生成霍夫曼编码。
5. 实现一个函数用于解码霍夫曼编码。
6. 编写主函数，进行实验验证。
五、实验过程1. 定义结构体HuffmanNode，用于存储字符及其频率。
```cppstruct HuffmanNode {char ch;int weight;HuffmanNode lchild, rchild;};```2. 实现一个函数用于统计字符频率。
```cppvoid StatFrequency(char str, int freq) {int length = strlen(str);for (int i = 0; i < 256; ++i) {freq[i] = 0;}for (int i = 0; i < length; ++i) {freq[(int)str[i]]++;}}```3. 实现一个函数用于构建霍夫曼树。
```cppHuffmanNode CreateHuffmanTree(int freq, int length) {HuffmanNode nodes = new HuffmanNode[length + 1];for (int i = 0; i < length; ++i) {nodes[i].ch = 'a' + i;nodes[i].weight = freq[i];nodes[i].lchild = nullptr;nodes[i].rchild = nullptr;}for (int i = length; i < length + 1; ++i) {nodes[i].ch = '\0';nodes[i].weight = 0;nodes[i].lchild = nullptr;nodes[i].rchild = nullptr;}for (int i = 0; i < length - 1; ++i) {HuffmanNode minNode1 = &nodes[0];HuffmanNode minNode2 = &nodes[1];for (int j = 0; j < length + 1; ++j) {if (nodes[j].weight < minNode1->weight) {minNode2 = minNode1;minNode1 = &nodes[j];} else if (nodes[j].weight < minNode2->weight && nodes[j].weight > minNode1->weight) {minNode2 = &nodes[j];}}nodes[i].weight = minNode1->weight + minNode2->weight;nodes[i].lchild = minNode1;nodes[i].rchild = minNode2;minNode1->parent = &nodes[i];minNode2->parent = &nodes[i];}return &nodes[length - 1];}```4. 实现一个函数用于生成霍夫曼编码。
数据结构实验实验报告Huffman赫夫曼编码及应用
实验报告课程名称：数据结构实验名称：赫夫曼编码及应用院（系）：计算机与通信工程学院专业班级：计算机科学与技术姓名：学号：指导教师：2020 年 5 月12 日一、实验目的掌握赫夫曼树和赫夫曼编码的基本思想和算法的程序实现。
二、实验内容及要求1、任务描述a.提取原始文件中的数据（包括中文、英文或其他字符），根据数据出现的频率为权重，b.构建Huffman编码表；c.根据Huffman编码表对原始文件进行加密，得到加密文件并保存到硬盘上；d.将加密文件进行解密，得到解码文件并保存点硬盘上；e.比对原始文件和解码文件的一致性，得出是否一致的结论。
2、主要数据类型与变量a.对Huffman树采用双亲孩子表示法，便于在加密与解密时的操作。
typedef struct Huffman* HuffmanTree;struct Huffman{unsigned int weight; //权值unsigned int p, l, r;//双亲，左右孩子};b．对文本中出现的所有字符用链表进行存储。
typedef struct statistics* List;struct statistics {char str; //存储此字符int Frequency; //出现的频率（次数）string FinalNum; //Huffman编码struct statistics* Next;};3、算法或程序模块对读取到的文本进行逐字符遍历，统计每个字符出现的次数，并记录在创建的链表中。
借助Huffman树结构，生成结构数组，先存储在文本中出现的所有字符以及它们出现的频率（即权值），当作树的叶子节点。
再根据叶子节点生成它们的双亲节点，同样存入Huffman树中。
在完成对Huffman树的创建与存储之后，根据树节点的双亲节点域以及孩子节点域，生成每个字符的Huffman编码，并存入该字符所在链表节点的FinalNum域。
计算机系统结构课设huffman编码实现
《计算机系统结构教程》课程设计实验报告（课程设计题目：hufferman指令优化）专业 ********************班级********************学号*****学生姓名 ********任课教师 ********2016年4月一、课设目的1）学习简单的文件输入输出程序设计；2）掌握huffman树的构建的方法；3）在指令操作码的优化上huffman编码可以实现操作码编码的优化，用最短的位数来表示指令的操作信息和地址信息。
二、任务要求1) 使用哈夫曼编码来优化指令操作码编码。
2）数据的输入、输出通过文件操作。
3）输出编码、信息熵、平均码长、以及生成的huffman树形三、开发环境操作系统：Windows 10开发工具：Eclipse环境 jdk1.8四、项目原理及算法思想哈夫曼树（Huffman tree），又名最优树，指给定n个权值作为n的叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman tree)。
哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。
假设有n个权值，则构造出的哈夫曼树有n个叶子结点。
n个权值分别设为w1、w2、…、wn，则哈夫曼树的构造规则为：(1) 将w1、w2、…，wn看成是有n 棵树的森林(每棵树仅有一个结点)；(2) 在森林中选出两个根结点的权值最小的树合并，作为一棵新树的左、右子树，且新树的根结点权值为其左、右子树根结点权值之和；(3)从森林中删除选取的两棵树，并将新树加入森林；(4)重复(2)、(3)步，直到森林中只剩一棵树为止，该树即为所求得的哈夫曼树。
将每个字符的出现频率作为字符结点的权值赋予该结点上，显然字使用频率越小权值越小，权值越小叶子就越靠下，于是频率小编码长，频率高编码短，这样就保证了此树的最小带权路径长度效果上就是传送报文的最短长度。
Huffman编解码实验报告
Huffman编解码实验报告⽂本⽂件的⼆进制预统计Huffman编解码⼀、实验⽬的(1) 熟悉Huffman编解码算法；(2) 理解Huffman编码的最佳性。
⼆、实验内容1、编程思想霍夫曼（Huffman）编码是1952年为⽂本⽂件⽽建⽴，是⼀种统计编码。
属于⽆损压缩编码。
霍夫曼编码的码长是变化的，对于出现频率⾼的信息，编码的长度较短；⽽对于出现频率低的信息，编码长度较长。
这样，处理全部信息的总码长⼀定⼩于实际信息的符号长度。
计算机编程实现时，⾸先统计带编码的⽂本⽂件中各个字符出现的概率，然后将概率作为节点的权值构建huffman树。
编码时从叶⼦节点出发，如果这个节点在左⼦树上，则编码0，否则编码1，直到根节点为⽌，所得到的01序列即为该叶⼦节点的编码。
所有叶⼦节点的编码构成⼀个码本。
有两种译码⽅法：(1)按位读⼊码字，从已建好的Huffman树的根节点开始，若码字为“0”，则跳到左⼦树，若为“1”则跳到右⼦树，直到叶⼦结点为⽌，输出叶⼦接点所表⽰的符号。
（2）由于Huffman编码是唯⼀码，还有另⼀种译码⽅法，每读⼊⼀位编码就去码本中去匹配相应的码字，若匹配不成功，则继续读⼊下⼀个编码，直到匹配成功为⽌。
显然前⼀种⽅法⽐较简便，本程序采⽤便是该⽅法。
2、程序流程图3、编程实现本实验采⽤⽤C 语⾔程序语⾔，VC++ 6.0编程环境。
(1)数据结构构造存放符号及其权值的存储结构如下 typedef struct {unsigned char symbol; //符号的ASCII 码值 int sweight; //权值}syml_weit;syml_weit *sw;构造huffman 树存储结构如下：typedef struct {int weit; //权值int lchd; //左孩⼦地址 int rchd; //右孩⼦地址 int part; //双亲地址 }hufmtree;hufmtree *htree;(2)函数本程序共包含5个函数：⼀个主函数：void main()， 4个⼦函数：void CountWeight(unsigned char *DataBuf,int FileLen); void BuildTree();void HufmCode(unsigned char *DataBuf,int FileLen); void HufmDCode(unsigned char *CDataBuf,int CDataLen); 其功能分别CountWeight----计算⽂本⽂件中各符号的权值； BuildTree-------构建Huffman 树，形成码本； HufmCode---------对⽂本⽂件进⾏编码； HufmDCode-------进⾏译码。
数据结构试验报告霍夫曼编码(DOCX页)
数据结构试验报告霍夫曼编码（DOC X页）数据结构实验报告(三)学院自动化学院学号姓名日期 2014-12-09实验目的1、掌握哈夫曼编码原理;2、熟练掌握哈夫曼树的生成方法;3、理解数据编码压缩和译码输出编码的实现;4、掌握二叉树的基本3操作。
实验内容利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。
这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码(解码)。
对于双工信道(即可以双向传输信息的信道)，每端都需要一个完整的编/译码系统。
试为这样的信息收发站设计一个哈夫曼编/译码系统。
实验要求1) 初始化(Initialzation)。
利用下表给出的字符集和频度的=;实际统计数据建立哈夫曼树，并将它存于文件hfmTree中;字符空格 A B C D E F G H I J K L M 频度 186 64 13 22 32 103 21 1547 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 12) 编码(EnCoding)。
利用已建好的哈夫曼树(若不在内存中，则从文件hfmTree中读入)，对以下报文进行编码，结果存入文件CodeFile中;报文内容:THIS PROGRAM IS MY FAVORITE3) 译码(Decoding)。
利用已建好的哈夫曼树，对文件CodeFile中编码后的报文进行解码，结果存入文件Textfile中;4) 输出(Output)。
输出字符集中每个字符的哈夫曼编码;输出原始报文，及其编码文件CodeFile和解码文件Textfile的内容。
扩展要求:将2)的编码结果以二进制形式存入CodeFile中，输出原始报文长度和编码后的报文长度。
1 需求分析(1) 将实验要求中的表格写在文件“HfmTree.txt”中，程序初始化时从该文件中读取字符及其频度，并据此建立Hfm树，生成编码表，打印出编码表; (2) 编码:用上一步生成的编码表，对报文进行编码，考虑到数据压缩性，这一步将编码结果以二进制文件进行存储，文件名为CodeFile; (3) 解码:从文件CodeFile中读入编码后的报文，利用建立好的Hfm树对其进行一一解码，输出解码结果，同时将结果存入Textfile.txt中; 2 概要设计因本次实验涉及许多字符串的操作，文件读写，并且除了霍夫曼树外，还用到了许多其他数据结构，而本次实验重点在霍夫曼树上，为了省去编写其他数据结构的时间，本次实验选用了C#语言和 .NetFrameWork 4.0来实现。
计算机体系结构实验-对指令操作码进行霍夫曼编码
CENTRAL SOUTH UNIVERSITY计算机体系结构实验报告题目对指令操作码进行霍夫曼编码一、实验目的了解和掌握指令编码的基本要求和基本原理。
二、实验环境Eclipse IDE for Java Developers（Version: Kepler Release）Win7三、实验内容使用编程工具编写一个程序，对一组指令进行霍夫曼编码，并输出最后的编码结果以及对指令码的长度进行评价。
与扩展操作码和等长编码进行比较。
问题描述以及问题分析：我们举例说明此问题，例如：最短编码长度为：H=0.45*1+0.30*2+0.15*3+0.05*4+0.03*5+0.01*6+0.01*6=-1.95.要对指令的操作码进行HUFFMAN编码，只要根据指令的各类操作码的出现概率构造HUFFMAN树再进行HUFFAM编码。
此过程的难点构造HUFFMAN树，进行HUFFAM编码只要对你所生成的HUFFMAN树进行中序遍历即可完成编码工作。
四、关键代码哈夫曼树重点在于如何排列权值大小不同的结点的顺序private int leafNum; //叶子结点个数private HaffmanNode[] hnodes; //哈夫曼树的结点数组public HaffManCode(double[] weight) //构造指定权值集合的哈夫曼树 {int n = weight.length; //n个叶子结点this.leafNum = n;this.hnodes = new HaffmanNode[2*n-1]; //n个叶子结点的哈夫曼树共有2n-1个结点for(int i=0; i<n; i++) //结点数组初始化有n个叶子结点this.hnodes[i] = new HaffmanNode(weight[i]);for(int i=0; i<n-1; i++) //构造n-1个2度结点，每循环一次，构造一个2度结点{double min1, min2;int x1, x2;min1 = min2 = Integer.MAX_VALUE; //选择最小和次最小权值，初值为最大权值x1 = x2 = -1; //记录两个无父母的最小权值结点下标for(int j=0; j<n+i; j++) //查找两个无父母的最小权值结点{if(hnodes[j].weight<min1 && hnodes[j].parent==-1){min2 = min1;x2 = x1;min1 = hnodes[j].weight; //min1记下最小权值x1 = j; //x1记下最小权值结点的下标}else if(hnodes[j].weight<min2 && hnodes[j].parent==-1){min2 = hnodes[j].weight;x2 = j; //x2记下次最小权值结点的下标}}五、运行截图及源代码源代码：package对指令操作码进行霍夫曼编码;class HaffmanNode //哈夫曼树的结点类{double weight; //权值int parent,left,right; //父母结点和左右孩子下标public HaffmanNode(double weight){this.weight = weight;this.parent=-1;this.left=-1;this.right=-1;}public HaffmanNode(){this(0);}public String toString(){return this.weight+" "+this.parent+" "+this.left+" "+this.right; }}public class HaffManCode{private int leafNum; //叶子结点个数private HaffmanNode[] hnodes; //哈夫曼树的结点数组public HaffManCode(double[] weight) //构造指定权值集合的哈夫曼树 {int n = weight.length; //n个叶子结点this.leafNum = n;this.hnodes= new HaffmanNode[2*n-1]; //n个叶子结点的哈夫曼树共有2n-1个结点for(int i=0; i<n; i++) //结点数组初始化有n个叶子结点this.hnodes[i] = new HaffmanNode(weight[i]);for(int i=0; i<n-1; i++) //构造n-1个2度结点，每循环一次，构造一个2度结点{double min1, min2;int x1, x2;min1 = min2 = Integer.MAX_VALUE; //选择最小和次最小权值，初值为最大权值x1 = x2 = -1; //记录两个无父母的最小权值结点下标for(int j=0; j<n+i; j++) //查找两个无父母的最小权值结点 {if(hnodes[j].weight<min1 && hnodes[j].parent==-1){min2 = min1;x2 = x1;min1 = hnodes[j].weight; //min1记下最小权值x1 = j; //x1记下最小权值结点的下标}else if(hnodes[j].weight<min2 && hnodes[j].parent==-1){min2 = hnodes[j].weight;x2 = j; //x2记下次最小权值结点的下标}}hnodes[x1].parent = n+i; //将找出的两棵权值最小的子树合并为一棵子树hnodes[x2].parent = n+i;this.hnodes[n+i] = new HaffmanNode();hnodes[n+i].weight = hnodes[x1].weight+hnodes[x2].weight;hnodes[n+i].left = x1;hnodes[n+i].right = x2;}}public String toString(){String str="";for (int i=0; i<this.hnodes.length && hnodes[i]!=null; i++)str += " "+i+" "+this.hnodes[i].toString()+"\n";return str;}String[] code1 = null;public String[] haffmanCode() //返回当前哈夫曼树的哈夫曼编码 {c ode1 = new String[this.leafNum];S tring[] code = new String[this.leafNum];for(int i=0; i<this.leafNum; i++) //求n个叶子结点的哈夫曼编码{code[i]="";int child = i;int parent = hnodes[child].parent;while (parent!=-1) //由叶结点向上直到根结点循环{if(hnodes[parent].left==child) {code[i]="0"+code[i]; //左孩子结点编码为0code1[i] = code[i];}else {code[i]="1"+code[i]; //右孩子结点编码为1code1[i] = code[i];}child = parent;parent = hnodes[child].parent;}}return code;}public double shortestLong() {i nt lng;d ouble weight, shortestlong = 0;f or(int i=0; i<this.leafNum; i++) {lng = code1[i].length();weight = hnodes[i].weight;shortestlong = shortestlong + lng*weight;}r eturn shortestlong;}public static void main(String[] args){//int[] weight={186, 64, 13, 22, 32, 103, 21, 15, 47, 57, 1, 5, 32, 20}; //指定权值集合d ouble[] weight={0.1, 0.2, 0.1, 0.3, 0.1, 0.2};HaffManCode htree = new HaffManCode(weight);System.out.println("指令权值父指左子右子\n"+htree.toString());String[] code = htree.haffmanCode();System.out.println("哈夫曼编码:");for (int i=0; i<code.length; i++) {System.out.println(code[i]);}System.out.println("最短编码长度为:" + htree.shortestLong());}}。
数据结构实验报告 huffman编码和解码算法
（规格为A4纸或A3纸折叠）佛山科学技术学院（用四号宋体）实验报告（用小二号黑体）课程名称数据结构实验实验项目用Huffman树进行编码和解码算法专业班级姓名学号指导教师成绩日期（用小四号宋体）一、目的和要求1、通过本实验，熟悉二叉树、Huffman树的基本概念，掌握二叉树的存储结构及各种算法。
2、熟悉用Huffman树进行电文的加密与解密算法。
二、实验原理Huffman树是一种特殊的二叉树，其叶结点的编码是一种前缀码，同时，通过统计字符的频度，能够达到编码电文的最小化。
三、实验步骤1、统计电文中字符的出现频率。
2. 用统计频率建立Hffman树。
3．生成前缀码；4．建立huffman树的解码算法．5．用随机输入的电文完成编码与解码过程。
四、源程序#include <stdio.h>#include <stdlib.h>#include <string.h>#define MAX 100struct HTNode{char a;int weight;int parent,lchild,rchild;}*HT; //动态分配数组存储赫夫曼树char **HC;int n=0,m=0;char *write()//存储输入的电文{char *p,*q;printf("请输入电文(结束输入请按enter）：\n");p=(char *)malloc(MAX*sizeof(char));//申请存储输入的电文的空间if(!p) exit(0);q=p;scanf("%c",q);while(*q!='\n'){//******录入电文，每录入一个字符同时给电文长度计数器n加一*******//*****************遇到换行符时结束录入***************n=n+1;if(n>=MAX)//判断已申请的空间是否足够录入，不足则追加空间{p=(char *)realloc(q,(MAX+10)*sizeof(char));if(!p) exit(0);}q++;scanf("%c",q);}return(p);}void weight(char *p)//求电文中各字符的概率，并将该概率当作各字符的权值{char *q,*q1,temp;struct HTNode *q2;int i,j,t;q1=q=(char *)malloc(n*sizeof(char));for(;*p!='\n';p++,q1++) *q1=*p;//将电文存放到q1指向的空间中q1=q;for(i=0;i<n-1;i++){//*****对电文中的字符进行排序，使得相同的字符地址连续，方便统计***** t=i;for(j=i+1;j<n;j++)if(*(q1+t)>*(q1+j)) t=j;temp=*(q1+i);*(q1+i)=*(q1+t);*(q1+t)=temp;}temp=*q1;//标记当前为何种字符m=1;for(i=1;i<n;i++)//统计电文中出现过不同的字符的个数{q1++;if(temp!=*q1){m++;//字符种类计数器加一temp=*q1;}}q1=q;HT=(struct HTNode *)malloc(2*m*sizeof(struct HTNode));/*申请赫夫曼树HT的空间，其中0号单元不用*/q2=HT+1;//*****************初始化赫夫曼树HT*********************for(i=1;i<=n;){t=0;for(q2->a=*q1;*q1==q2->a;q1++){t++;i++;}q2->weight=(int)(t*100/n);q2->lchild=0;q2->parent=0;q2->rchild=0;q2++;}for(i=m+1;i<=2*m-1;i++,q2++){q2->lchild=0;q2->parent=0;q2->rchild=0;q2->weight=0;}free(q);}void Select(int t,int *s1,int *s2){/************在HT[1，t]选择parent为0且weight最小的两个结点，其序号分别为s1和s2。
计算机系统结构——课后答案
习题一1、解释下列术语计算机系统的外特性：通常所讲的计算机系统结构的外特性是指机器语言程序员或编译程序编写者所看到的外特性，即由他们所看到的计算机的基本属性（概念性结构和功能特性）。
计算机系统的内特性：计算机系统的设计人员所看到的基本属性，本质上是为了将有关软件人员的基本属性加以逻辑实现的基本属性。
模拟：模拟方法是指用软件方法在一台现有的计算机上实现另一台计算机的指令系统。
可移植性：在新型号机出台后，原来开发的软件仍能继续在升级换代的新型号机器上使用，这就要求软件具有可兼容性，即可移植性。
可兼容性是指一个软件可不经修改或只需少量修改，便可由一台机器移植到另一台机器上运行，即同一软件可应用于不同环境。
Amdahl 定律：系统中对于某一部件采用某种更快的执行方式所能获得的系统性能改进程度，取决于这种执行方式被使用的频度或占总执行时间的比例。
虚拟机（Virtual Machine ）：指通过软件模拟的具有完整硬件系统功能的、运行在一个完全隔离环境中的完整计算机系统。
6、7、假定求浮点数平方根的操作在某台机器上的一个基准测试程序中占总执行时间的20%，为了增强该操作的性能，可采用两种不同的方法：一种是增加专门的硬件，可使求浮点数平方根操作的速度提高为原来的20倍；另一种方法是提高所有浮点运算指令的速度，使其为原来的2倍，而浮点运算指令的执行时间在总执行时间中占30%。
试比较这两种方法哪一种更好些。
答：增加硬件的方法的加速比23.120/2.0)2.01(11=+-=p S ,另一种方法的加速比176.12/3.0)3.01(12=+-=p S ，经计算可知Sp1>Sp2第一种方法更好些。
9、假设高速缓存Cache 的工作速度为主存的5倍，且Cache 被访问命中的概率为90%，则采用Cache 能使整个存储系统获得多高的加速比？ 答：加速比%10)(%90'⨯++⨯==tc tm tc tmT T S ，其中tm=5tc ，代入公式，得到加速比S=3.33。
霍夫曼编码
1．复习C++代码基本语法（结构体、树等数据结构定义） 2．根据Huffman 编码源代码，学习算法实现流程，培养自己动手能 力，在C++编译器下按步调试跟踪算法。
三、实验仪器、设备
1．计算机－系统最低配置 256M 内存、P4 CPU。 2．C++ 编程软件 － Visual C++ 7.0 （Microsoft Visual Studio 2003）
步骤2： 在步骤1中得到的树林里找出频率值最小的两棵树，将他们 分别作为左、右子树连成一棵大一些的二叉树，该二叉树的频率值设为 两棵子树频率之和。
步骤3： 对上面得到的树林重复步骤2的做法，直到所有符号都连入 树中为止。
五、实验步骤
1．VC 环境下，建一个C++控制台应用程序，并把源代码考到该程序 目录下。
七、思考题
根据Huffman 算法的C＋＋源程序，试着写出Huffman 编码的Matlab 程
序？
编码流程： 1. 读入一幅图像的灰度值; 2. 将矩阵的不同数统计在数组c的第一列中; 3. 将相同的数占站整个数组总数的比例统计在数组p中; 4. 找到最小的概率,相加直到等于1,把最小概率的序号存在tree第 一列中,次小放在第二列,和放在p像素比例之后; 5. C数组第一维表示值,第二维表示代码数值大小,第三维表示代码 的位数； 6. 把概率小的值为1标识，概率大的值为0标识； 7. 计算信源的熵 ； 8. 计算平均码长 ； 9. 计算编码效率'；
10. 计算冗余度。
Huffman编码m文件及分析
function [h,l]=huffman(p) if (length(find(p<0))~=0)
湘潭大学 数据结构实验8 实验报告 源代码 赫夫曼编码
“数据结构和算法II”课程实验报告实验名称：赫夫曼编码及其应用班级姓名学号实验日期：实验机时：2 学时实验成绩：-------------------------------------------------------------------------------一.实验目的：掌握赫夫曼树的概念、存储结构掌握建立赫夫曼树和赫夫曼编码的方法及带权路径长度的计算熟练掌握二叉树的应用二.实验内容：（1）基本实验内容：实现赫夫曼树的生成，完成赫夫曼编码的输出；（2）扩展实验内容：完成一组码字的赫夫曼编码及解码(以一个文本文件的内容为例).三.程序及注释：#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;creathfmt(ht);printhfmt(ht);phfmnode(ht);printf("\n------------------------------------------------------------------\n");printf("***************************编码&&译码&&退出**********************");printf("\n[1]编码\t[2]译码\t[0]退出");printf("\n您的选择是：");flag=getchar();getchar();while(flag!='0'){ if(flag=='1')encoding(ht);else if(flag=='2')decoding(ht);elseprintf("您的输入有误，请重新输入\n");printf("\n***************************编码&&译码&&退出**********************"); printf("\n[1]编码\t[2]译码\t[0]退出");printf("\n您的选择是：");flag=getchar();getchar(); }printf("\n\n-----------------------------------------------------------------\n"); printf("***************欢迎使用哈夫曼编码系统*******************\n");printf("-----------------------------------------------------------------\n");system("pause"); }四.运行结果：五.实验心得：通过本次课程设计，我对二叉树和赫夫曼树有了更好的认识，在实验过程中，我掌握了赫夫曼树的构造方法，学会了如何将理论知识转换成实际应用。
霍夫曼编码的实验报告(3篇)
第1篇一、实验目的1. 理解霍夫曼编码的基本原理和实现方法。
2. 掌握霍夫曼编码在数据压缩中的应用。
3. 通过实验，加深对数据压缩技术的理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 20194. 数据源：文本文件三、实验原理霍夫曼编码是一种常用的数据压缩算法，适用于无损数据压缩。
它通过使用变长编码表对数据进行编码，频率高的数据项使用短编码，频率低的数据项使用长编码。
霍夫曼编码的核心是构建一棵霍夫曼树，该树是一种最优二叉树，用于表示编码规则。
霍夫曼编码的步骤如下：1. 统计数据源中每个字符的出现频率。
2. 根据字符频率构建一棵最优二叉树，频率高的字符位于树的上层，频率低的字符位于树下层。
3. 根据最优二叉树生成编码规则，频率高的字符分配较短的编码，频率低的字符分配较长的编码。
4. 使用编码规则对数据进行编码，生成压缩后的数据。
5. 在解码过程中，根据编码规则恢复原始数据。
四、实验步骤1. 读取文本文件，统计每个字符的出现频率。
2. 根据字符频率构建最优二叉树。
3. 根据最优二叉树生成编码规则。
4. 使用编码规则对数据进行编码，生成压缩后的数据。
5. 将压缩后的数据写入文件。
6. 读取压缩后的数据，根据编码规则进行解码，恢复原始数据。
7. 比较原始数据和恢复后的数据，验证压缩和解码的正确性。
五、实验结果与分析1. 实验数据实验中，我们使用了一个包含10000个字符的文本文件作为数据源。
在统计字符频率时，我们发现字符“e”的出现频率最高，为2621次，而字符“z”的出现频率最低，为4次。
2. 实验结果根据实验数据，我们构建了最优二叉树，并生成了编码规则。
使用编码规则对数据源进行编码，压缩后的数据长度为7800个字符。
将压缩后的数据写入文件，文件大小为78KB。
接下来，我们读取压缩后的数据，根据编码规则进行解码，恢复原始数据。
比较原始数据和恢复后的数据，发现两者完全一致，验证了压缩和解码的正确性。
数据结构实验报告-霍夫曼编码
院系：计算机学院实验课程：数据结构实验实验项目：实验五霍夫曼编码/译码指导老师：开课时间：专业：计算机类班级：学生：学号：实验五霍夫曼编码/译码1.综设实验题目霍夫曼编码/译码2.中文摘要本实验是利用霍夫曼编码这一经典的数据编码方式来实现一个编码和解码的软件，实现了对指定文本的压缩功能，和对被压缩过的文件进行解压缩，恢复为原来的文件。
3.关键词课程名称数据结构实验实验项目霍夫曼编码/译码实验时间年月日实验指导老师实验评分霍夫曼编码压缩C++4.前言实验目的：利用霍夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。
这要求在发送端通过一个编码系统对待传输数据预先编码，在接收端将传来的数据进行译码（复原）。
对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。
实验意义：方便对通讯网络或数据传输中对数据进行压缩，减少数据所占用的资源空间。
实验内容：主要是初始化霍夫曼树、编码、解码。
5.实验设计由于该实验主要涉及到树这一存储结构，因此整个实验的关键点便在于对树这个数据结构的建立和操作上。
这个霍夫曼树主要有以下功能：由树转化成字符和编码的映射表、保存映射表、获取树的根节点、初始化树、利用映射表对文本进行编码、利用映射表对压缩过的文本进行解压缩，还有打印树的内容。
6.实验实现主要功能模块有：由树转化成字符和编码的映射表、保存映射表、获取树的根节点、初始化树、利用映射表对文本进行编码、利用映射表对压缩过的文本进行解压缩，还有打印树的内容。
由树转化成字符和编码的映射表是getCode()函数，代码如下：void Huffman::getCode() {stack< pair<node*, string> > s;s.push(make_pair(root, "0"));pair<node*, string> temp;while (!s.empty()) {temp = s.top();s.pop();if (temp.first->lchild == NULL && temp.first->rchild == NULL) {code[temp.first->data] = temp.second;code_reverse[temp.second] = temp.first->data;continue;}if (temp.first->lchild != NULL) s.push(make_pair(temp.first->lchild, temp.second + "0"));课程名称数据结构实验实验项目霍夫曼编码/译码实验时间年月日实验指导老师实验评分if (temp.first->rchild != NULL) s.push(make_pair(temp.first->rchild, temp.second + "1"));}return;}这个函数是对树进行前序遍历，每次访问到叶子节点时就保存这时的编码串和叶子结点所表示的字符。
编码理论实验报告实验一霍夫曼编码中信息熵及编码效率的实验
编码理论实验报告实验一霍夫曼编码中信息熵及编码效率的实验实验名称实验一霍夫曼编码中信息熵及编码效率的实验一、实验目的1. 掌握霍夫曼编码中信息熵的定义、性质和计算;2. 掌握霍夫曼编码中平均码字长度的定义和计算;3( 掌握霍夫曼编码中编码效率的定义和计算;4. 正确使用C语言实现霍夫曼编码中信息熵、平均码长和编码效率的求取。
二、实验内容1. 熟练列出霍夫曼编码中信息熵、平均码长和编码效率各自的计算公式;2. 正确使用C语言实现计算霍夫曼编码中信息熵、平均码长和编码效率的程序，并在Visual C++环境中验证。
三、实验原理1. 霍夫曼编码的基本原理按照概率大小顺序排列信源符号，并设法按逆顺序分配码字字长，使编码的码字为可辨识的。
2. 平均码长:L=?p(s)*l(单位为:码符号/信源符号) ii其中，p(s)为信源s在q个信源中出现的概率，l为信源s的二进制霍夫曼iiii编码。
3. 信息熵:H(S)=- ?p(s) *log p(s) (单位为:比特/信源符号) i2i其中，p(s)为信源s在q个信源中出现的概率。
ii4. 编码效率:η= H(S)/ L其中，H(S)为信息熵，L为平均码长。
四、实验步骤:1. Huffman编码示例如下图:信源符号概率信源缩减过程编码码长00 0 S1 0.4 0.4 0.4 0.6 00 2 1 0000 1 S2 0.2 0.2 0.4 0.4 10 2 01 1010 01 S3 0.2 0.2 0.2 11 2 11010 11 S4 0.15 0.2 010 3011 S5 0.05 011 3 2. 根据Huffman编码的例子，用C语言完成计算霍夫曼编码中信息熵的程序的编写，并在Visual C++环境中验证;3. 根据Huffman编码的例子，用C语言完成计算霍夫曼编码中平均码长的程序的编写，并在Visual C++环境中验证;4. 根据Huffman编码的例子，用C语言完成计算霍夫曼编码中编码效率的程序的编写，并在Visual C++环境中验证;实验程序:/*********** 霍夫曼编码信息熵、平均码长及编码效率的计算 ************ //按照实验步骤的要求完成程序，正确计算霍夫曼编码的信息熵、 //平均码长以及编码效率，并通过printf函数将三者的计算结果 //打印出来#include<stdio.h>#include<string.h>#include<math.h>#define CH_Num 5 //信源符号个数//主函数void main(){//编程1:定义double型数组gailv存放各信源符号出现的概率double gailv[CH_Num]={0.4,0.2,0.2,0.15,0.05};//编程2:定义int型数组code_len存放各信源符号的霍夫曼编码int code_len[CH_Num]={2,2,2,3,3};//编程3:定义double型变量aver_Len、Hs和code_ratio，分别//对应信息熵、平均码长及编码效率，并初始化为0double aver_Len=0,Hs=0,code_ratio=0;int i;//编程4:利用for循环计算平均码长aver_Lenfor(i=0;i<CH_Num;i++)aver_Len+=gailv[i]*code_len[i];//编程5:利用for循环计算信息熵Hsfor(i=0;i<CH_Num;++i)Hs+=-(gailv[i]*(log(gailv[i])/log(2)));//编程6:计算编码效率code_ratiocode_ratio=Hs/aver_Len;//编程7:利用三条printf语句分别打印平均码长、信息熵和编码效率printf("平均码长=%lf 比特/信源符号\n",aver_Len);printf("信源熵=%lf 码符号/信源符号\n",Hs);printf("编码效率=%lf\n",code_ratio); }运行结果如下图:实验心得:通过本次试验加深了对霍夫曼编码的基本原理的理解以及计算公式的记忆。
霍夫曼编码实验报告(C )
一、实验名称：霍夫曼编码 二、实验环境
软件环境：Windows 2000，Microsoft Visual C++6.0 硬件环境：P4，2.4GHz，256 内存，IBM-PC 及兼容机 三、实验目的 掌握霍夫曼编码、译码原理，并能够通过程序模拟其编码、译码功能。 四、实验原理 1、消息按其出现的概率由大到小地排成一个概率序列； 2、把概率最小两个消息分成一组，其中一个消息编为 0，另一个编为 1，然 后求其概率和，并把这个新概率与其他尚未处理过的概率重新按概率由大到小排 成一个新的概率序列； 3、重复步骤，直到所有概率都已联合处理完为止。 五、实验过程与实验结果 源程序：
if(HT[f].lchild==c) {
cd[--start]='0'; } else {
cd[--start]='1'; } code_length[i]+=1; } HC[i]=(char*)malloc((n-start)*sizeof(char)); strcpy(HC[i],&cd[start]); } free(cd); } //初始化 /*功能：从终端读入字符集大小 n，以及 n 个字符和 n 个权值，建立霍夫曼树， 并将它存于文件 hfmTree 中。*/ int Initialization() { Init_htnode(); Create_hfmtree(); Hfm_coding(); return 0; }
for(j=i+1;j<=n;j++) if(HT[j].ch==HT[i].ch) { flag=0; break;
计算机科学与工程系
}
}
return flag;
编码理论实验报告实验二信源编码——霍夫曼编码
实验名称 实验二 信源编码--------霍夫曼编码一、 实验目的1. 掌握信息熵的定义、性质和计算；2. 掌握平均码字长度和编码效率的计算；3． 掌握霍夫曼编码的原理；4． 熟练掌握二进制霍夫曼码的编码步骤；5． 正确使用C 语言实现霍夫曼编码。
二、实验内容1. 熟练画出霍夫曼编码图，正确求出字符串的二进制霍夫曼编码；2. 用C 语言正确编程，实现霍夫曼编码、解码，并在Visual C++环境中验证。
三、 实验原理1. 霍夫曼编码的基本原理按照概率大小顺序排列信源符号，并设法按逆顺序分配码字字长，使编码的码字为可辨识的。
2. 平均码长：L=∑p(s i )*l i （单位为：码符号/信源符号）其中，p(s i )为信源s i 在q 个信源中出现的概率，l i 为信源s i 的二进制霍夫曼编码。
3. 信息熵：H(S)=- ∑p(s i ) *log 2 p(s i ) （单位为：比特/信源符号）其中，p(s i )为信源s i 在q 个信源中出现的概率。
4. 编码效率：η= H(S)/ L其中，H(S)为信息熵，L 为平均码长。
四、 实验步骤：1. 将q 个信源符号按概率分布的大小，以递减次序排列起来，设 )()()(21q x p x p x p ≥≥≥2. 用“0”和“1”码符号分别代表概率最小的两个信源符号，并将这两个概率最小的符号合并成一个符号，合并的符号概率为两个符号概率之和，从而得到只包含q-1个符号的新信源，称为缩减信源。
3. 把缩减信源的符号仍旧按概率大小以递减次序排列，再将其概率最小的两个信源符号分别用“0”和“1”表示，并将其合并成一个符号，概率为两符号概率之和，这样又形成了q – 2 个符号的缩减信源。
4. 依此继续下去，直至信源只剩下两个符号为止。
将这最后两个信源符号分别用“0”和“1”表示。
5. 然后从最后一级缩减信源开始，向前返回，就得出各信源符号所对应的码符号序列，即对应的码字。
实验一 霍夫曼编码以及程序
9 2 H3 0 7 15 8 H4 ④ 步骤D： 0 7 15 8 H4 9 1 6 6 H2 9 4 9 2 H3 7 0 3 0 A 7 3 3 5 H1 8 0
4 0 D 8 0 5 0 B 6 0 2 0 C 6 0 1 0 E 0 1 0 0 0 1 1 1 于是得到最后的霍夫曼编码为： 字符 A B 霍夫曼编 码 00 11 C 010 D 10 E 011
三．问题描述：
已知n个字符在原文中出现的频率，求它们的霍夫曼编码。 1、读入n个字符，以及字符的权值，试建立一棵Huffman树。 2、根据生成的Huffman树，求每个字符的Huffman编码。并对给定 的待编码字符序列进行ypedef struct{ unsigned int weight; unsigned int parent,lchild,rchild; }HTNode,*HuffmanTree; //动态分配数组存储霍夫曼树 霍夫曼树节点的图形表示： parent lchild weight rchild （2）霍夫曼编码的过程： A．首先输入n个待编码的字符data及其权值weight，并将n个字符的 权值放入到霍夫曼树的节点中。 B．用select函数遍历n个字符，找出权值最小的两个S1和S2，构造 一个新的节点Hi，将S1和S2连接到Hi的lchild和rchild节点上，Hi节点的 weight为S1和S2的weight之和。 C．将新建立的节点Hi替换S1和S2，继续步骤b（这时的字符数为ni，i=1,2，…），直到只剩下一个节点为止。至此，霍夫曼树构造完 成。 D．给霍夫曼树HT分配编码，并输出。 （3）具体实例 步骤A：输入的n=5，字符A-E的权值为输入，字符H1-H4为将来构
cd[--start]='1'; } HC[i]=(char*)malloc((n-start)*sizeof(char)); //为第i个字 符编码分配空间 strcpy(HC[i],&cd[start]);//从cd复制编码到HC } free(cd); //释放工作空间 } void main() { int n,i; int* w; //记录权值 char* ch; //记录字符 HuffmanTree HT; HuffmanCode HC; cout<<"请输入待编码的字符个数n="; cin>>n; w=(int*)malloc((n+1)*sizeof(int)); //记录权值，号单元未 用 ch=(char*)malloc((n+1)*sizeof(char));//记录字符，号单元未 用 cout<<"依次输入待编码的字符data及其权值weight"<<endl; for(i=1;i<=n;i++) { cout<<"data["<<i<<"]="; cin>>ch[i]; cout<<"weight["<<i<<"]="; cin>>w[i]; } HuffmanCoding(HT,HC,w,n); //输出字符及其编码 for(i=1;i<=n;i++)cout<<ch[i]<<" "<<HC[i]<<endl; system("pause"); }
霍夫曼编码(含源程序)
多媒体技术基础实验报告——霍夫曼编码学院：电子工程与光电技术学院专业：电子信息工程姓名：学号：任课老师：康其桔实验时间：一、实验内容及要求1、使用Matlab 编程实现霍夫曼编码2、通过键盘输入字符串3、在屏幕上显示编码结果二、实验原理霍夫曼编码是霍夫曼在1952年提出和描述的“从下到上”的熵编码方法。
根据给定数据集中各元素所出现的频率来压缩数据的一种统计压缩编码方法。
这些元素(如字母)出现的次数越多，其编码的位数就越少。
其基本步骤为： (1) 将压缩的各字符的出现概率按减少(或增加)的顺序进行排列。
(2) 将两个最小的概率进行组合相加得到一个新概率将这一新概率与其它概率一起继续执行1 和2 的操作直至最后概率为1.0。
(3) 对每对组合中的概率较大者指定为1,较小者指定为0。
(4) 画出由每个信源符号概率到1.0处的路径记下路径的1和0。
(5) 对每个信源符号由从右到左写出1/0序列，对概率较高的标1，对概率较低的标0(或对概率较高的标0，对概率较低的标1)，就得到了对应的Huffman 码。
下面举个例子来说明霍夫曼编码的具体过程。
设需要编码的信息为：BACDEBACDEBACDEBADEBAEBABABABB,统计各个字符出现的次数分别为B(10次)、A(8次)、C(3次)、D(4次)、E(5次)。
各个字符出现的概率为B(10/30)、A(8/30)、E(5/30)、D(4/30)、C(3/30)。
霍夫曼编码的过程如下： B(10/30)A(8/30)E(5/30) D(4/30) C(3/30) 霍夫曼编码后平均码长为2(10/308/305/30)3(4/303/30) 2.23b ⨯+++⨯+≈ 。
而信源熵 2.19H b =。
由此，我们可以看出，霍夫曼编码结果已经很接近理想信源熵。
三、设计方案设计的流程图如下：7/30 12/3018/30 30/30 B:11 A:10 E:00 D:011 C:010 1 010 0 1 1 0四、各模块设计（一）读入字符串并去除空格在Matalb中使用语句inputstring=input('请输入需要编码的字符:','s')，输入的字符串存入char型数组inputstring中。
计算机体系结构报告
中南大学计算机体系结构实验报告学生姓名代巍指导教师雷向东学院信息科学与工程学院专业班级信安1201班学号 0909121615 完成时间 2014年11月20日实验 1 对指令操作码进行霍夫曼编码一、实验目的了解和掌握指令编码的基本要求和基本原理二、实验要求使用编程工具编写一个程序，对一组指令进行霍夫曼编码，并输出最后的编码结果以及对指令码的长度进行评价。
与扩展操作码和等长编码进行比较。
问题描述以及问题分析：我们举例说明此问题，例如：有一组指令的操作码共分七类，它们出现概率如下表所示：P1 P2 P3 P4 P5 P6 P70.45 0.30 0.15 0.05 0.03 0.01 0.01对此组指令进行 HUFFMAN 编码正如下图所示：三、实验内容因为各字符在信息中出现的频率是不同的，若根据字符出现的不同频率分配给不同长度的编码：频繁出现的字符分配给较短的编码，不常出现的字符分配给较长的编码，且这种编码还具有“前缀特性”，那么这样的编码电文总长会最短，发送效率会最高，占用的空间会最少。
而哈弗曼编码就是这样一种编码，字符出现的频率与该程序中对应的权重。
首先将建立哈弗曼树，将权重最小的放在二叉树的最低端，将权重最大的放置在离根结点最近的位置，这样就可以使权重大的结点的编码较短，权重小的结点的编码较长。
实际上是建立一个表格，中间有结点的权重，父亲和孩子的信息。
建立好哈弗曼树之后，要使得哈弗曼的左子树的编码为0，右子树的编码为1。
可以通过这个来确定字符的哈弗曼编码。
四、实验原理构造 HUFFMAN 树所要做的工作：1、先对各指令操作码的出现概率进行排序，构造一个有序链表。
2、再取出两个最小的概率节点相加，生成一个生的节点加入到链表中，同时从两表中删除此两个节点。
3、在对链表进行排序，链表是否只有一个节点，是则 HUFFAN 树构造完毕，否则继续做 2 的操作。
为此设计一个工作链表（链表的元素时类，此类的功能相当结构。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
elseif(hnodes[j].weight<min2 &&hnodes[j].parent==-1)
{
min2 =hnodes[j].weight;
x2 = j;//x2记下次最小权值结点的下标
}
}
hnodes[x1].parent= n+i;//将找出的两棵权值最小的子树合并为一棵子树
hnodes[x2].parent= n+i;
publicHaffManCode(double[] weight) //构造指定权值集合的哈夫曼树
{
intn = weight.length; //n个叶子结点
this.leafNum = n;
this.hnodes =newHaffmanNode[2*n-1]; //n个叶子结点的哈夫曼树共有2n-1个结点
for(inti=0; i<n-1; i++)//构造n-1个2度结点，每循环一次，构造一个2度结点
{
doublemin1, min2;
intx1, x2;
min1 = min2 = Integer.MAX_VALUE;//选择最小和次最小权值，初值为最大权值
x1 = x2 = -1;//记录两个无父母的最小权值结点下标
for(inti=0; i<n; i++) //结点数组初始化有n个叶子结点
this.hnodes[i] =newHaffmanNode(weight[i]);
for(inti=0; i<n-1; i++) //构造n-1个2度结点，每循环一次，构造一个2度结点
{
doublemin1, min2;
intx1, x2;
this.leafNum= n;
this.hnodes=newHaffmanNode[2*n-1];//n个叶子结点的哈夫曼树共有2n-1个结点
for(inti=0; i<n; i++)//结点数组初始化有n个叶子结点
this.hnodes[i] =newHaffmanNode(weight[i]);
min1 = min2 = Integer.MAX_VALUE;//选择最小和次最小权值，初值为最大权值
x1 =x2 = -1;//记录两个无父母的最小权值结点下标
for(intj=0; j<n+i; j++)//查找两个无父母的最小权值结点
{
if(hnodes[j].weight<min1 && hnodes[j].parent==-1)
{
String str="";
for(intj=0; j<n+i; j++)//查找两个无父母的最小权值结点
{
if(hnodes[j].weight<min1 &&hnodes[j].parent==-1)
{
min2 = min1;
x2 = x1;
min1 =hnodes[j].weight;//min1记下最小权值
x1 = j;//x1记下最小权值结点的下标
以及对指令码的长度进行评价。与扩展操作码和等长编码进行比较。
问题描述以及问题分析：
我们举例说明此问题，例如：
最短编码长度为：
H=0.45*1+0.30*2+0.15*3+0.05*4+0.03*5+0.01*6+0.01*6=-1.95.
要对指令的操作码进行HUFFMAN编码，只要根据指令的各类操作码的出现概率构造
{
min2 = min1;
x2 = x1;
min1 = hnodes[j].weight; //min1记下最小权值
x1 = j; //x1记下最小权值结点的下标
}
elseif(hnodes[j].weight<min2 && hnodes[j].parent==-1)
{
min2 = hnodes[j].weight;
{
this.weight= weight;
this.parent=-1;
this.left=-1;
this.right=-1;
}
publicHaffmanNode()
{
this(0);
}
publicString toString()
{
returnthis.weight+" "+this.parent+" "+this.left+" "+this.right;
this.hnodes[n+i] =newHaffmanNode();
hnodes[n+i].weight=hnodes[x1].weight+hnodes[x2].weight;
hnodes[n+i].left= x1;
hnodes[n+i].right= x2;
}
}
publicString toString()
HUFFMAN树再进行HUFFAM编码。此过程的难点构造HUFFMAN树，进行HUFFAM编
码只要对你所生成的HUFFMAN树进行中序遍历即可完成编码工作。
四、关键代码
哈夫曼树重点在于如何排列权值大小不同的结点的顺序
privateintleafNum; //叶子结点个数
privateHaffmanNode[] hnodes; //哈夫曼树的结点数组
CENTRAL SOUTH UNIVERSITY
计算机体系结构实验报告
题目对指令操作码进行霍夫曼编码
一、实验目的
了解和掌握指令编码的基本要求和基本原理。
二、实验环境
Eclipse IDE for Java Developers（Version: Kepler Release）
Win7
三、实验内容
使用编程工具编写一个程序，对一组指令进行霍夫曼编码，并输出最后的编码结果
x2 = j; //x2记下次最小权值结点的下标
}
}
五、运行截图及源代码
源代码：
package对指令操作码进行霍夫曼编码;
classHaffmanNode//哈夫曼树的结点类
{
doubleweight;//权值
intparent,left,right;//父母结点和左右孩子下标
publicHaffmanNode(doubleweight)
}
}
publicclassHaffManCode
{
privateintleafNum;//叶子结ቤተ መጻሕፍቲ ባይዱ个数
privateHaffmanNode[]hnodes;//哈夫曼树的结点数组
publicHaffManCode(double[] weight)//构造指定权值集合的哈夫曼树
{
intn = weight.length;//n个叶子结点