实验六_赫夫曼编码
huffman编码实验
一、实验目的 1、学习 Matlab 软件的使用和编程； 2、进一步深入理解 Huffman 编码算法的原理； 3、提高独立进行算法编程的能力。 二、实验内容 1、用 Matlab 实现 Huffman 编码算法程序； 2、要求程序输出显示所有的码字以及编码效率； 3、设计简单的输入界面（可以是简单的文字提示信息） ，程序运 行时提示用户输入代表信源符号概率的向量； 要对用户输入的概 率向量进行合法性检查。 三、实验原理 1、二进制 Huffman 编码的基本原理及算法 (1) 把信源符号集中的所有符号按概率从大到小排队。 (2) 取概率最小的两个符号作为两片叶子合并（缩减）到一个 节点。 (3) 视此节点为新符号， 其概率等于被合并 （缩减） 的两个概率之和， 参与概率排队。 (4) 重复(2)(3)两步骤，直至全部符号都被合并（缩减）到根。 (5) 从根出发，对各分枝标记 0 和 1。从根到叶的路径就给出了各个 码字的编码和码长。 2、程序设计的原理 (1)程序的输入： 以一维数组的形式输入要进行 huffman 编码的信源
% 矩阵 c 的第 n-i 的
第一个元素的 n-1 的字符赋值为对应于 a 矩阵中
第 n-i+1 行中值为 1 的位置在 c 矩阵中的编码值
c(n-i,n)='0' %根据之前的规则，在分支的第一个元素最后补 0 c(n-i,n+1:2*n-1)=c(n-i,1:n-1) %矩阵 c 的第 n-i 的第二个元素的 n-1 的字符与第 n-i 行的第一个元素
符号的概率，在运行该程序前，显示文字提示信息，提示所要输入的 概率矢量；然后对输入的概率矢量进行合法性判断，原则为：如果概 率矢量中存在小于 0 的项，则输入不合法，提示重新输入；如果概率 矢量的求和大于 1，则输入也不合法，提示重新输入。 （2）huffman 编码具体实现原理： 1>在输入的概率矩阵 p 正确的前提条件下,对 p 进行排序， 并用 矩阵 L 记录 p 排序之前各元素的顺序， 然后将排序后的概率数组 p 的 前两项，即概率最小的两个数加和，得到新的一组概率序列，重复以 上过程， 最后得到一个记录概率加和过程的矩阵 p 以及每次排序之前 概率顺序的矩阵 a。 2>新生成一个 n-1 行 n 列， 并且每个元素含有 n 个字符的空白矩 阵，然后进行 huffman 编码： � 将 c 矩阵的第 n-1 行的第一和第二个元素分别令为 0 和 1（表示 在编码时，根节点之下的概率较小的元素后补 0，概率较大的元 素后补 1，后面的编码都遵守这个原则） � 然后对 n-i-1 的第一、 二个元素进行编码， 首先在矩阵 a 中第 n-i 行找到值为 1 所在的位置，然后在 c 矩阵中第 n-i 行中找到对应 位置的编码（该编码即为第 n-i-1 行第一、二个元素的根节点） ， 则矩阵 c 的第 n-i 行的第一、二个元素的 n-1 的字符为以上求得 的编码值，根据之前的规则，第一个元素最后补 0，第二个元素 最后补 1，则完成该行的第一二个元素的编码， � 最后将该行的其他元素按照“矩阵 c 中第 n-i 行第 j+1 列的值等
Huffman编码实验报告
图像Huffman编码实验报告
1 实验目的
(1)熟练掌握Huffman编码的方法；
(2)理解无失真信源编码和限失真编码方法在实际图像信源编码应用中的差异。
2 实验内容与步骤
(1)针对“image1.bmp”、“image2.bmp”和“image3.bmp”进行灰度频率统计（即计算图像灰度直方图），在此基础上添加函数代码构造Huffman码表，针对图像数据进行Huffman编码，观察和分析不同图像信源的平均码长、编码效率和压缩比。
(2)针对任意一幅图像，得到其差分图像，对差分图像统计灰度频率，进行Huffman编码，计算平均码长、编码效率和压缩比，并与（1）对比。
3 实验结果
（1）对图像数据进行Huffman 编码，得到不同图像信源的平均码长、编码效率和压缩比如下：
image1：5.960179 0.994678 1.342242
image2：4.443604 0.992368 1.800341
image3：6.733643 0.996281 1.188064
(2)对lenna.bmp 进行Huffman 编码，得到其平均码长、编码效率和压缩比分别是：
5.294220 0.994358 1.511082。
《哈夫曼编码》实验报告
《哈夫曼编码》实验报告《哈夫曼编码》实验报告一、实验目的1、掌握哈夫曼编码原理；2、熟练掌握哈夫曼树的生成方法；3、理解数据编码压缩和译码输出编码的实现。
二、实验要求实现哈夫曼编码和译码的生成算法。
三、实验步骤编写代码如下：#include#include#include#define MAXLEN 100typedef struct{int weight;int lchild;int rchild;int parent;char key;}htnode;typedef htnode hfmt[MAXLEN];int n;void inithfmt(hfmt t)｛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;int i;char k;for(i=0;i<n;i++)< bdsfid="112" p=""></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].lc hild,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++)< bdsfid="190" p=""></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++)< bdsfid="207" p=""></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;printf("\n\n请输入需要译码的字符串:");gets(r);len=strlen(r);printf("译码的结果是:");for(i=0;i<len;i++)< bdsfid="222" p=""></len;i++)<> {if(r[i]=='0'){j=t[j].lchild;if(t[j].lchild==-1){printf("%c",t[j].key);j=2*n-2;}}else if(r[i]=='1'){j=t[j].rchild;if(t[j].rchild==-1){printf("%c",t[j].key);j=2*n-2;}}printf("\n\n");}int main(){int i,j;hfmt ht;char flag;printf("\n----------------------------------------------\n");printf("*******************编码&&译码&&退出***************");printf("\n【1】编码\t【2】\t译码\t【0】退出");printf("\n您的选择：");flag=getchar();getchar();while(flag!='0'){if(flag=='1')encoding(ht);else if(flag=='2')decoding(ht);elseprintf("您的输入有误，请重新输入。
霍夫曼编码设计实验报告
一、实验目的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域。
哈夫曼编码的实验报告
哈夫曼编码的实验报告哈夫曼编码的实验报告一、引言信息的传输和存储是现代社会中不可或缺的一部分。
然而，随着信息量的不断增加，如何高效地表示和压缩信息成为了一个重要的问题。
在这个实验报告中，我们将探讨哈夫曼编码这一种高效的信息压缩算法。
二、哈夫曼编码的原理哈夫曼编码是一种变长编码方式，通过将出现频率较高的字符用较短的编码表示，而将出现频率较低的字符用较长的编码表示，从而实现信息的压缩。
它的核心思想是利用统计特性，将出现频率较高的字符用较短的编码表示，从而减少整体编码长度。
三、实验过程1. 统计字符频率在实验中，我们首先需要统计待压缩的文本中各个字符的出现频率。
通过遍历文本，我们可以得到每个字符出现的次数。
2. 构建哈夫曼树根据字符频率，我们可以构建哈夫曼树。
哈夫曼树是一种特殊的二叉树，其中每个叶子节点代表一个字符，并且叶子节点的权值与字符的频率相关。
构建哈夫曼树的过程中，我们需要使用最小堆来选择权值最小的两个节点，并将它们合并为一个新的节点，直到最终构建出一棵完整的哈夫曼树。
3. 生成编码表通过遍历哈夫曼树，我们可以得到每个字符对应的编码。
在遍历过程中，我们记录下每个字符的路径，左边走为0，右边走为1，从而生成编码表。
4. 进行编码和解码在得到编码表后，我们可以将原始文本进行编码，将每个字符替换为对应的编码。
编码后的文本长度将会大大减少。
为了验证编码的正确性，我们还需要进行解码，将编码后的文本还原为原始文本。
四、实验结果我们选取了一段英文文本作为实验数据，并进行了哈夫曼编码。
经过编码后，原始文本长度从1000个字符减少到了500个字符。
解码后的文本与原始文本完全一致，验证了哈夫曼编码的正确性。
五、讨论与总结哈夫曼编码作为一种高效的信息压缩算法，具有广泛的应用前景。
通过将出现频率较高的字符用较短的编码表示，哈夫曼编码可以在一定程度上减小信息的存储和传输成本。
然而，哈夫曼编码也存在一些局限性，例如对于出现频率相近的字符，编码长度可能会相差较大。
数据结构实验——赫夫曼编码
实习三二叉树应用一、实验目的：熟悉二叉树的存储结构，二叉树的有关的操作。
二、实验内容及要求：哈夫曼编/译码器[问题描述]利用哈夫曼编码进行通信可以大大提高信道利用率，这要求在发送端通过一个编码系统对待传输预先编码，在接收端将传来的数据进行译码。
对于双工通道，每端都需要一个完整的编/译码系统。
[基本要求]试为这样的信息收发站写一个哈夫曼码的编/译码系统。
[实现提示]构造哈夫曼树的算法实现：假设哈夫曼树采用双亲孩子表示法存储，并增加权值域，构造哈夫曼树的叶子结点（树木的权）有N个，合并次数为N—1次，则森林中总共有2N—1棵树，（包含合并后删除的）。
存储结构描述为：const int n=maxn //maxn表示叶子数目const int m=2*n-1 //m为森林中树的棵数class tree{float weight; //权值int parent; //双亲int lch, rch; //左，右孩子}tree hftree[m+1]; //规定从第一个元素hftree[1]开始使用数组元素，故定义长度为m+1而不为m结构类型：typedef struct{char data;int weight;int parent;int lchild;int rchild;}huffnode;typedef struct{char cd[MAX];int start;}huffcode;主程序int main(){初始化：输入字符代码以及权值。
编制哈夫曼码：根据权值建立二叉树, 输出相应的根节点到叶结点的路径,便是哈夫曼编码。
编码：输入字符,输出哈夫曼码。
译码：输入哈夫曼,输出字符代码。
退出：结束进程,退出程序。
三、实验题目：构造哈弗曼树的算法。
四、实验源代码：#include<iostream.h>#include<string.h>#include<stdio.h>typedef struct{char word;int weight;int parent,lchild,rchild;}htnode,*huffmantree;void select(huffmantree ht,int a,int &s1,int &s2){ht[0].weight=1000;s1=0;for(int i=1;i<=a;i++){if(ht[i].parent==0){if(ht[i].weight<ht[s1].weight){s1=i;}}}ht[s1].parent=1;s2=0;for(i=1;i<=a;i++){if(ht[i].parent==0){if(ht[i].weight<ht[s2].weight){s2=i;}}}}void creathuffmantree(huffmantree &ht,int N) {int m=2*N-1;int s1,s2;for(int i=N+1;i<=m;i++){select(ht,i-1,s1,s2);ht[s1].parent=i;ht[s2].parent=i;ht[i].lchild=s1;ht[i].rchild=s2;ht[i].weight=ht[s1].weight+ht[s2].weight;ht[i].word='x';}}typedef char **huffmancode;void creathuffmancode(huffmantree ht,huffmancode &hc,int N){hc=new char*[N+1];char *cd=new char[N];cd[N-1]='\0';int start,c,f;for(int i=1;i<=N;i++){start=N-1;c=i;f=ht[i].parent;while(f!=0){--start;if(ht[f].lchild==c)cd[start]='0';elsecd[start]='1';c=f;f=ht[f].parent;}hc[i]=new char[N-start];strcpy(hc[i],&cd[start]);delete cd;}void bianma(huffmancode hc,huffmantree ht,char *a,int N){int i=0,j;cout<<"该字母组的赫夫曼编码是：";while(a[i]!='\0'){for(j=1;j<=N;j++){if(ht[j].word==a[i])break;}cout<<hc[j];i++;}cout<<endl;}void changetozimu(huffmantree ht,char b[],int{int i=0,f=2*N-1;cout<<"该赫夫曼编码的含义是："<<endl;while(b[i]!='\0'){if(b[i]=='0'){f=ht[f].lchild;if(ht[f].lchild!=0){i++;}else{cout<<ht[f].word;i++;f=2*N-1;}}else if(b[i]=='1'){f=ht[f].rchild;if(ht[f].rchild!=0){i++;}else{cout<<ht[f].word;i++;f=2*N-1;}}else{cout<<"出现错误输入";break;}}cout<<endl;}void main(){int N;cout<<"请输入字母的数字"<<endl;cin>>N;huffmantree ht=new htnode[2*N];for(int i=1;i<=2*N-1;i++){ht[i].parent=0;ht[i].lchild=0;ht[i].rchild=0;}for(i=1;i<=N;i++){cout<<"请输入第"<<i<<"个字母"<<endl;cin>>ht[i].word;cout<<"请输入该字母的权值"<<endl;cin>>ht[i].weight;}creathuffmantree(ht,N);cout<<"哈弗曼树："<<endl;for(i=1;i<=2*N-1;i++){cout<<ht[i].word<<" ";cout<<ht[i].weight<<" ";cout<<ht[i].parent<<" ";cout<<ht[i].lchild<<" ";cout<<ht[i].rchild<<endl;}huffmancode hc;creathuffmancode(ht,hc,N);cout<<"哈弗曼编码："<<endl;for(i=1;i<=N;i++){cout<<ht[i].word<<" ";cout<<hc[i]<<endl;}char *a=new char[100];cout<<"输入少于100个的字母符号"<<endl;cin>>a;bianma(hc,ht,a,N);cout<<"请输入一段少于100的赫夫曼编码"<<endl;char b[100];cin>>b;changetozimu(ht,b,N);}五、实验源代码运行结果截图：。
信息论 实验六 Huffman编码
实验六 Huffman 编码一、实验目的：掌握Huffman 编码的方法二、实验内容：对信源123456,,,,,()0.250.250.020.150.10.05a a a a a a X P X ⎧⎫⎛⎫=⎨⎬ ⎪⎝⎭⎩⎭进行二进制Huffman 编码。
并计算其平均码长，编码效率。
三、实验步骤（1）将概率按从小到大的顺序排列（2）给两个概率最小的信源符号1()P a 和2()P a 各分配一个码位“0”和“1”，将这两个信源符号合并成一个新符号，并用这两个最小的概率之和最为新符号的概率，结果得到一个只包含（n-1）个信源符号的新信源，称为信源的第一次缩减信源，用S1表示。
（3）将缩减信源S1的符号仍按概率从大到小的顺序排列，重复步骤2，得到只含（n-2）个符号的缩减信源S2。
（4）重复上述步骤，直至缩减信源只剩两个符号为止，此时所剩的两个符号的概率之和为1。
然后从最后一级缩减信源开始，依编码路径向前返回，就得到各信源符号所对应的码字。
四、实验数据及结果分析（1）将信源符号按概率从小到大的顺序排列。
P=（0.25 0.25 0.2 0.15 0.1 0.05）；（2）输出每个灰度级的编码00010000001111001（3）计算其平均码长和编码效率平均码长L=2.4500编码效率xiaolv=0.9891（4）运行截图如下所示：图一运行及结果五、代码附录n=input('N=');%输入信源符号的个数L=0; H=0;for i=1:nP(i)=input('P=');%输入信源符号概率分布s=s+P(i);endif s~=1error('不符合概率分布');endP=sort(P);p=P;mark=zeros(n-1,n); %mark为n-1行，n列矩阵，用来记录每行概率排列次序for i=1:n-1[P,num]=sort(P); %对输入元素排序并记录mark(i,:)=[num(1:n-i+1),zeros(1,i-1)];P=[P(1)+P(2),P(3:n),1];endfor i=1:n-1table(i,:)=blanks(n*n); %blanks 创建空格串endtable(n-1,n)='1';table(n-1,2*n)='0'for i=2:n-1table(n-i,1:n-1)=table(n-i+1,n*(find(mark(n-i+1,:)==1))-(n-2):n*(find(mark(n-i+1,:)==1))); %按mark的记录依次赋值table(n-i,n)='1';table(n-i,n+1:2*n-1)=table(n-i,1:n-1);table(n-i,2*n)='0';for j=1:i-1table(n-i,(j+1)*n+1:(j+2)*n)=table(n-i+1,n*(find(mark(n-i+1,:)==j+1)-1)+1:n*find(mark(n-i+1,:)==j+1));%mark的记录依次赋值endend%得到编码后的码字for i=1:nW(i,1:n)=table(1,n*(find(mark(1,:)==i)-1)+1:find(mark(1,:)==i)*n);l(i)=length(find(abs(W(i,:))~=32));%32表示空字符，要找不是空字符的个数，即为每个数编码的个数L=L+p(i)*l(i); %计算平均码长H=H-p(i)*log2(p(i));%计算信源熵endxiaolv=H/L; %计算编码效率disp('输出每个概率的编码');disp(W);disp('输出平均码长L：');disp(L);disp('输出编码效率xiaolv：');disp(xiaolv);六，实验总结：通过该实验，掌握了Huffman编码。
实习报告6_哈夫曼编码
1.初始化：从文件（程序运行时，由用户输入）读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，将它存于文件中。
2.编码：利用已建好的哈夫曼树（如不在内存，则从文件中读入）对文件字符集中的每一个进行编码，将结果放在中。
3.译码：利用已建好的哈夫曼树将中的代码进行译码，结果保存在中。
4.印代码文件。
将文件以紧凑的格式显示在终端上，每行50个代码。
同时将结果保存在中。
二.概要设计：1.哈夫曼树的抽象数据类型定义：ADT haffman{ 数据对象：D={ai|ai为charnode型的结点，i=1，2，3，……n，n>0}数据关系：R={<ai,><ai,>|ai是D上的元素}} ADT haffman2.编码集结构体的抽象数据类型的定义：ADT code{ 数据对象：D1={ai| ai是charlink型的结点，i=1，2，……n，n>0}D2={bi|bi是codelink型的结点，i=1，2，……n，n>0}数据关系： R1={<ai,>|ai是D1上的元素}R2={<bi,>|bi是D2上的元素}} ADT code3.程序分为四个部分：1）读入字符集以及相应频度，建立哈夫曼树。
2）根据哈夫曼树得到每一个字符的哈夫曼编码。
3）读入要编码的字符串，根据哈夫曼树和编码集求出字符串的哈夫曼编码。
4）根据哈夫曼编码和哈夫曼树得到字符串。
三.详细设计：h >> hufW[ ii ].wt;}(); .eight<< setw( 8 ) << hufT[ tOut ].parent<< setw( 8 ) << hufT[ tOut ].lChild<< setw( 8 ) << hufT[ tOut ].rChild << endl;}hufTreeOutPut << "-- end HT --------------------------- " << endl << endl << "-- HC ------------------------------- " << endl;for( int cOut = 1 ; cOut <= hufNum ; cOut++ ){hufTreeOutPut << " " << hufC[ cOut ].ch << " ---->> " << hufC[ cOut ].hufCh << endl;}hufTreeOutPut << "-- convert -- ok -------------------- " << endl;(); t;p->parent = p->lChild = p->rChild = 0; i-1 ]选择parent 为 0 且weight 最小的两个结点，其序号分别为 s1 和 s2arent = i; arent = i; Child = s1; Child = s2; eight =HT[ s1 ].weight + HT[ s2 ].weight; arent ; f != 0 ; c = f , f =HT[ f ].parent ) Child == c ) { cd[ --start ] = '0'; }else { cd[ --start ] = '1'; }}HC[ i ].ch = w[ i-1 ].ch ; ufCh = ( char* ) malloc ( ( n - start ) * sizeof( char ) ); ufCh , &cd[ start ] ); arent != 0 ) continue;else{sm1 = HT[ m ].weight;s1=m;break;}}for( int j = m+1 ; j <= i ; j++ ) arent != 0 ) continue;else{if( sm1 > HT[ j ].weight ){sm1 = HT[ j ].weight;s1 = j;}}}for( m = 1 ; m <= i ; m++ ) arent != 0 ) continue;else{sm2 = HT[ m ].weight;s2=m;if( s2 == s1 ) continue;else break;}}for( int k = m+1 ; k <= i ; k++ ) arent != 0 ) continue;else{if( (HT[ k ].weight < sm2) && ( k != s1 ) ) eight;s2 = k;}}}} ufCh == ' 'fOut << HC[ sub ].hufCh;}else if( inBuf == '\n' ){continue;}else{ufCh == 'A'. 以下的字符雷同sub = inBuf - 63;fOut << HC[ sub ].hufCh;}}HT[p]就为 HT 的根.Child != 0 ) Child; ufCh , cd ) == 0 ){fOut << HC[ iHC ].ch;break; Child; Child != 0 ) Child; ufCh , cd ) == 0 ){fOut << HC[ iHC ].ch;break; Child; ufCh , cd ) == 0 ){fOut << HC[ iHC ].ch;break; ufCh , cd ) == 0 ){fOut << HC[ iHC ].ch;break; 试分析1.本次作业在打印树形结构的时候有点遗憾，其他的都应该做的完美的了。
Huffman编码实验报告
Huffman编码实验报告1 二进制哈夫曼编码的原理及步骤（1）信源编码的计算设有N 个码元组成的离散、无记忆符号集，其中每个符号由一个二进制码字表示，信源符号个数n 、信源的概率分布P={p(s i )},i=1,…..,n 。
且各符号xi 的以li 个码元编码，在变长字编码时每个符号的平均码长为∑==ni li xi p L 1)( ；信源熵为：)(log )()(1xi p xi p X H ni ∑=-= ；唯一可译码的充要条件：11≤∑=-ni Ki m ；其中m 为码符号个数，n 为信源符号个数，Ki 为各码字长度。
构造哈夫曼数示例如下图所示。
（2）二元霍夫曼编码规则（1）将信源符号依出现概率递减顺序排序。
（2）给两个概率最小的信源符号各分配一个码位“0”和“1”，将两个信源符号合并成一个新符号，并用这两个最小的概率之和作为新符号的概率，结果得到一个只包含（n-1）个信源符号的新信源。
称为信源的第一次缩减信源，用s1 表示。
（3）将缩减信源 s1 的符号仍按概率从大到小顺序排列，重复步骤(2)，得到只含（n-2）个符号的缩减信源s2。
0.0.0.0.1.000.0.0.00.0.0.0.（4）重复上述步骤，直至缩减信源只剩两个符号为止，此时所剩两个符号 的概率之和必为 1，然后从最后一级缩减信源开始，依编码路径向前返回，就得到各信源符号所对应的码字。
2 功能介绍输入一段字符序列，通过本程序可得出该字符序列中各个字符出现的次数，以及每个字符出现的概率，并能计算出信源符号熵，每个字符的哈弗曼编码，和相应的平均码长，编码效率，码方差。
3 算法基本步骤描述4 C 语言源代码#include<stdio.h>#include<string.h>#include<math.h>#define MAX 100//定义全局变量h 存放信息熵double h=0; 得到信得出信源得出信源计算信输输输输输信源符号的码编码平均输//定义结构体用于存放信源符号，数目及概率typedef struct{//不同的字符char SOURCECODE;//不同字符出现的次数int NUM;//不同字符出现的概率double PROBABILITY;//哈夫曼编码符号int Code[MAX];int start;//哈夫曼树的父结点int parent;//哈夫曼树的左右子结点int lchild;int rchild;//哈夫曼编码的长度int lengthofhuffmancode;}Hcode;Hcode INFORMATION[MAX];//该函数用来求信源所包含的符号，以及不同符号出现的次数和概率int Pofeachsource(char informationsource[MAX],int a){int i,j=1,m,flag=0;char temp;//预先存入第一个字符，便于与后面的字符进行比较//统计不同的字符存入结构体数组中//利用flag标签来标记每个字符是否出现过，若出现过标记为1，否则置为零INFORMATION[0].SOURCECODE=informationsource[0];for(i=1;i<a;i++){ for(m=0;m<i;m++){flag=0;if(informationsource[m]==informationsource[i]){flag=1;break;}}if(flag==1)continue;elseINFORMATION[j++].SOURCECODE=informationsource[i];}INFORMATION[j].SOURCECODE='\0';printf("信源符号数为:%d\n",j);//统计相同的字符出现的次数//每做一个字符出现次数的统计都将结构体数组里的NUM置为零for(i=0;i<j;i++){ INFORMATION[i].NUM=0;for(m=0;m<a;m++)if(informationsource[m]==INFORMATION[i].SOURCECODE)INFORMATION[i].NUM++;}//统计每个字符出现的概率for(i=0;i<j;i++) INFORMATION[i].PROBABILITY=(float)INFORMATION[i].NUM/a;//将每个不同字符出现的次数概率都显示出来for(i=0;i<j;i++)printf("The NUM and PROBABILITY of Code'%c'is %dand %.3f\n",INFORMATION[i].SOURCECODE,INFORMATION[i].NUM,INFORMATION [i].PROBABILITY);return j;}//求信源符号的熵void H(int a){int i;for(i=0;i<a;i++){h+=((-1)*(INFORMATION[i].PROBABILITY)*(log(INFORMATION[i].PROBABI LITY)/log(2)));}}//哈夫曼编码函数void Huffman(int a){Hcode cd;int i,j,m=0,lm=0,p,c;double min,lmin;//顺序初始化每个信源父子结点为-1for(i=0;i<a;i++){INFORMATION[i].parent=-1;INFORMATION[i].lchild=-1;INFORMATION[i].lchild=-1;}cd.start--; /* 求编码的低一位 */c=p;p=INFORMATION[c].parent; /* 设置下一循环条件 */}//保存求出的每个叶结点的哈夫曼编码和编码的起始位for(j=cd.start+1;j<m;j++){ INFORMATION[i].Code[j]=cd.Code[j];}INFORMATION[i].start=cd.start;}}void main(){//定义存放信源符号的数组char informationsource[MAX];int i,j,m;double averageofhuffmancode=0.0,Eita,cV=0.0;printf("please input the source of information:");for(i=0;;i++){scanf("%c",&informationsource[i]);if(informationsource[i]=='\n')break;}informationsource[i]='\0';printf("信源序列为:");//显示已输入的一串信源符号puts(informationsource);//返回不同信源符号的数目m=Pofeachsource(informationsource,i);//求信源的符号熵H(m);printf("信源的符号熵:H(X)=%.3f(比特/符号)\n",h);Huffman(m);//输出已保存好的所有存在编码的哈夫曼编码for(i=0;i<m;i++){printf("%c's Huffman code is: ",INFORMATION[i].SOURCECODE); for(j=INFORMATION[i].start+1;j<m;j++)printf("%d",INFORMATION[i].Code[j]);INFORMATION[i].lengthofhuffmancode=m-INFORMATION[i].start-1; printf("\n");}//求哈夫曼编码的平均码长和编码效率for(i=0;i<m;i++)averageofhuffmancode+=INFORMATION[i].PROBABILITY*INFORMATION[i].l engthofhuffmancode;printf("哈夫曼编码的平均码长为:%lf(码元/信源符号)\n",averageofhuffmancode);Eita=h/averageofhuffmancode;printf("哈夫曼编码的编码效率为:%lf\n",Eita);//求哈弗曼编码的码方差for(i=0;i<m;i++)cV+=INFORMATION[i].PROBABILITY*INFORMATION[i].lengthofhuffmancode *INFORMATION[i].lengthofhuffmancode;cV-=averageofhuffmancode*averageofhuffmancode;printf("哈弗曼编码的码方差为：%lf\n",cV);}5 运行结果截图:6 实验分析（1）在哈弗曼编码的过程中，对缩减信源符号按概率有大到小的顺序重新排列，应使合并后的新符号尽可能排在靠前的位置，这样可使合并后的新符号重复编码次数减少，使短码得到充分利用。
数据结构哈夫曼编码实验报告
数据结构哈夫曼编码实验报告【正文】1.实验目的本实验旨在研究哈夫曼编码的原理和实现方法，通过实验验证哈夫曼编码在数据压缩中的有效性，并分析其应用场景和优缺点。
2.实验原理2.1 哈夫曼编码哈夫曼编码是一种无损数据压缩算法，通过根据字符出现的频率构建一颗哈夫曼树，将频率较高的字符用较短的编码表示，频率较低的字符用较长的编码表示。
哈夫曼编码的编码表是唯一的，且能够实现前缀编码，即一个编码不是另一个编码的前缀。
2.2 构建哈夫曼树构建哈夫曼树的过程如下：1) 将每个字符及其频率作为一个节点，构建一个节点集合。
2) 每次从节点集合中选择出现频率最低的两个节点，构建一个新节点，并将这两个节点从集合中删除。
3) 将新节点加入节点集合。
4) 重复以上步骤，直到节点集合中只有一个节点，这个节点就是哈夫曼树的根节点。
2.3 编码过程根据哈夫曼树，对每个字符进行编码：1) 从根节点开始，根据左子树为0，右子树为1的规则，将编码依次加入编码表。
2) 对于每个字符，根据编码表获取其编码。
3) 将编码存储起来，得到最终的编码序列。
3.实验步骤3.1 数据读取与统计从输入文件中读取字符序列，并统计各个字符的频率。
3.2 构建哈夫曼树根据字符频率构建哈夫曼树。
3.3 构建编码表根据哈夫曼树，构建每个字符的编码表。
3.4 进行编码根据编码表，对输入的字符序列进行编码。
3.5 进行解码根据哈夫曼树，对编码后的序列进行解码。
4.实验结果与分析4.1 压缩率分析计算原始数据和压缩后数据的比值，分析压缩率。
4.2 编码效率分析测试编码过程所需时间，分析编码效率。
4.3 解码效率分析测试解码过程所需时间，分析解码效率。
4.4 应用场景分析分析哈夫曼编码在实际应用中的优势和适用场景。
5.结论通过本次实验，我们深入了解了哈夫曼编码的原理和实现方法，实践了哈夫曼编码的过程，并对其在数据压缩中的有效性进行了验证。
实验结果表明，哈夫曼编码能够实现较高的压缩率和较高的编解码效率。
哈夫曼编码实验超详尽版
编码步骤
6
在F中选取两棵根结点权值最小的树作为新构造 的二叉树的左右子树，新二叉树的根结点的权 值为其左右子树的根结点的权值之和。 从F中删除这两棵树，并把这棵新的二叉树同样 以升序排列加入到集合F中。 重复二和三两步，直到集合F中只有一棵二叉树 为止。
示例
7
假如有A,B,C,D,E五个字符，出现的频率（即权值） 分别为5,4,3,2,1,那么我们第一步先取两个最小权值 作为左右子树构造一个新树，即取1，2构成新树， 其结点为1+2=3，如图：
原理
3
首先统计信源中各符号出现的概率，按符号出现的
概率从大到小排序； 把最小的两个概率相加合并成新的概率，与剩余的 概率组成新的概率集合； 对新的概率集合重新排序，再次把其中最小的两个 概率相加，组成新的概率集合。如此重复进行，直 到最后两个概率的和为l；原理4 Nhomakorabea
分配码字：码字分配从最后一步开始反向进行，
9
实现过程：首先通过 HuffmanTree() 函数构造哈夫 曼树，然后在主函数 main()中自底向上开始(也就 是从数组序号为零的结点开始)向上层层判断，若 在父结点左侧，则置码为 0,若在右侧,则置码为 1。 最后输出生成的编码。 typedef struct
{ int bit[MAXBIT]; int start; } HCodeType; /* 编码结构体 */
五、程序部分代码及其分析
13
/* 设置找到的两个子结点 x1、x2 的父结点信息 */ HuffNode[x1].parent = n+i; HuffNode[x2].parent = n+i; HuffNode[n+i].weight = HuffNode[x1].weight + HuffNode[x2].weight; HuffNode[n+i].lchild = x1; HuffNode[n+i].rchild = x2;
霍夫曼编码的实验报告(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哈夫曼编码实验的目的是掌握哈夫曼编码的原理，掌握哈夫曼树的生成方法。
了解数据压缩。
实验要求实现Huffman编解码器生成算法。
三。
实验内容首先统计待压缩文件中出现的字符和字母的数量，根据字符字母和空格的概率对其进行编码，然后读取要编码的文件并将其存储在另一个文件中；然后调用已编码的文件，对输出进行解码，最后存储到另一个文件中。
5实验原理1。
假设树的权值是用huffn树的定义来构造的。
每个加权叶为wi，权值路径最小的二叉树成为Huffman树或最优二叉树。
Huffman树的结构：权重是一个输入频率的数组，这些值根据节点对象中的数据属性按顺序分配给HTs，即每个HT节点对应一个输入频率。
然后，根据数据属性，从最小值到最大值取两个最小值和这个小HT节点，将它们的数据相加，构造一个新的htnode作为它们的父节点。
指针parentleftchild和rightchild被分配了相应的值。
将这个新节点插入最小堆。
按照这个程序，我们能建一棵树吗？通过构造的树，从下至上搜索父节点，直到父节点成为树的顶点。
这样，每次向上搜索后，根据原始节点是父节点的左子节点还是右子节点记录1或0。
每一个01都有一个完整的编码，每一个都有一个完整的编码。
初始化，以文本文件中的字符数为权值，生成Huffman树，按符号概率由大到小对符号进行排序，概率最小的两个符号形成一个节点。
重复步骤（）（），直到概率和为1，从根节点到每个符号对应的“叶”，概率高的符号标为“0”，概率低的符号从根节点开始，对符号7进行编码。
实验程序ා include<iostream>ා include<iomanip>ා include<iomanip>使用命名空间STD；typedef struct//节点结构{char data；//记录字符值long int weight；//记录字符权重unsigned int parent，lchild，rchild；}Htnode，*HuffmanTree；typedef char**huffmancode；//dynamicly allocate array to store Huffman code table void select（HuffmanTree&HT，int i，int&S1，int&S2）//选择HT[1中权重最小且父节点不为0的两个节点。
哈夫曼编码实验报告
哈夫曼编码实验报告霍夫曼（Huffman）编码属于码词长度可变的编码类，是霍夫曼在1952年提出的一种编码方法，即从下到上的编码方法。
同其他码词长度可变的编码一样，可区别的不同码词的生成是基于不同符号出现的不同概率。
生成霍夫曼编码算法基于一种称为“编码树”（coding tree）的技术。
算法步骤如下：（1）初始化，根据符号概率的大小按由大到小顺序对符号进行排序。
（2）把概率最小的两个符号组成一个新符号（节点），即新符号的概率等于这两个符号概率之和。
（3）重复第2步，直到形成一个符号为止（树），其概率最后等于1。
（4）从编码树的根开始回溯到原始的符号，并将每一下分枝赋值为1，上分枝赋值为0。
以下这个简单例子说明了这一过程。
1)．字母A,B,C,D,E已被编码，相应的出现概率如下：p(A)=0.16, p(B)=0.51, p(C)=0.09, p(D)=0.13, p(E)=0.11 2)．C和E概率最小，被排在第一棵二叉树中作为树叶。
它们的根节点CE的组合概率为0.20。
从CE到C的一边被标记为1，从CE到E的一边被标记为0。
这种标记是强制性的。
所以，不同的哈夫曼编码可能由相同的数据产生。
3)．各节点相应的概率如下：p(A)=0.16, p(B)=0.51, p(CE)=0.20, p(D)=0.13D和A两个节点的概率最小。
这两个节点作为叶子组合成一棵新的二叉树。
根节点AD的组合概率为0.29。
由AD到A的一边标记为1，由AD到D的一边标记为0。
如果不同的二叉树的根节点有相同的概率，那么具有从根到节点最短的最大路径的二叉树应先生成。
这样能保持编码的长度基本稳定。
4)．剩下节点的概率如下：p(AD)=0.29, p(B)=0.51, p(CE)=0.20AD和CE两节点的概率最小。
它们生成一棵二叉树。
其根节点ADCE 的组合概率为0.49。
由ADCE到AD一边标记为0，由ADCE到CE 的一边标记为1。
哈夫曼编码 实验报告
哈夫曼编码实验报告哈夫曼编码实验报告一、引言哈夫曼编码是一种用于数据压缩的算法，由大卫·哈夫曼于1952年提出。
它通过将出现频率高的字符用较短的编码表示，从而实现对数据的高效压缩。
本实验旨在通过实际操作和数据分析，深入了解哈夫曼编码的原理和应用。
二、实验目的1. 掌握哈夫曼编码的基本原理和算法；2. 实现哈夫曼编码的压缩和解压缩功能；3. 分析不同数据集上的压缩效果，并对结果进行评估。
三、实验过程1. 数据集准备本实验选取了三个不同的数据集，分别是一篇英文文章、一段中文文本和一段二进制数据。
这三个数据集具有不同的特点，可以用来评估哈夫曼编码在不同类型数据上的压缩效果。
2. 哈夫曼编码实现在实验中，我们使用了Python编程语言来实现哈夫曼编码的压缩和解压缩功能。
首先，我们需要统计数据集中各个字符的出现频率，并构建哈夫曼树。
然后，根据哈夫曼树生成每个字符的编码表，将原始数据转换为对应的编码。
最后，将编码后的数据存储为二进制文件，并记录编码表和原始数据的长度。
3. 压缩效果评估对于每个数据集，我们比较了原始数据和压缩后数据的大小差异，并计算了压缩比和压缩率。
压缩比是指压缩后数据的大小与原始数据大小的比值，压缩率是指压缩比乘以100%。
通过对比不同数据集上的压缩效果，我们可以评估哈夫曼编码在不同类型数据上的性能。
四、实验结果与分析1. 英文文章数据集对于一篇英文文章，经过哈夫曼编码压缩后，我们发现压缩比为0.6，即压缩后的数据只有原始数据的60%大小。
这说明哈夫曼编码在英文文本上具有较好的压缩效果。
原因在于英文文章中存在大量的重复字符，而哈夫曼编码能够利用字符的出现频率进行编码，从而减少数据的存储空间。
2. 中文文本数据集对于一段中文文本，我们发现哈夫曼编码的压缩效果不如在英文文章上的效果明显。
压缩比为0.8，即压缩后的数据只有原始数据的80%大小。
这是因为中文文本中的字符种类较多，并且出现频率相对均匀，导致哈夫曼编码的优势减弱。
赫夫曼编码(实验报告)
《数据结构课程设计》实验报告伊兵 110613119一、实验目的：掌握赫夫曼编码的存储，理解赫夫曼树的算法。
通过赫夫曼树的建立，完成赫夫曼编码的生成，并实现编码文件的译码。
二、内容与设计思想：（设计思想、主要数据结构、主要代码结构、主要代码段分析）主要数据结构1）赫夫曼树的存储结构定义：#define n 100//叶子结点数#define m 2*n-1//赫夫曼树中结点总数typedef struct{int weight;//权值int lchild,rchild,parent;//左右孩子及双亲指针}HTNode;//树中结点类型typedef HTNode HuffmanTree[m+1];//零号单元不用2）选择parent为0且权值最小的两个根结点的算法的定义：void select(HuffmanTree T,int k,int &s1,int &s2){//在HT[1...k]中选择parent为0且权值最小的两个根结点，其序号分别为s1和s2，并靠引用参数带回主调函数int i,j;int minl=101;for(i=1;i<=k;i++) //找s1if(T[i].weight<minl && T[i].parent==0){j=i;minl=T[i].weight;}s1=j;minl=32767;for(i=1;i<=k;i++) //找s2if(T[i].weight<minl && T[i].parent==0 && i!=s1){j=i;minl=T[i].weight;}s2=j;3）统计字符串中字符的种类以及各类字符的个数该算法的主要实现思想是：先定义一个含有26个元素的临时整型数组，用来存储各种字母出现的次数。
因为大写字母与小写字母相差64位，所以在算法中我们可以使用字母减去64作为统计数组的下标对号入座。
赫夫曼编码
西南石油大学上机实验报告1．掌握赫夫曼树特点及其构造2．掌握赫夫曼编码的实现方法二、实验内容根据给定的n个权值构造赫夫曼树并建立每个权值对应字符的赫夫曼编码。
三、实验说明1．采用静态三叉链表存储结构建立赫夫曼树，从叶子到根逆向求取每个字符赫夫曼编码，具体实现可参考教材P147算法6.122．程序运行后要求依次输出每个字符的赫夫曼编码。
四、算法实现#include<stdio.h>#include<string.h>#include<malloc.h>#define UNIT_MAX 10000typedef struct{unsigned int weight;unsigned int parent,lchild,rchild;}HTNode,*HuffmanTree;//动态分配数组存储赫夫曼树typedef char **HuffmanCode;//动态分配数组存储赫夫曼编码表int min(HuffmanTree t,int i){//返回i个结点中权值最小的树的根结点序号int j,flag;unsigned int k=UNIT_MAX;//取k为不小于可能的值(无符号整型最大值)for(j=1;j<=i;j++)if(t[j].weight<k&&t[j].parent==0)//t[j]是树的根结点{k=t[j].weight;flag=j;}t[flag].parent=1;//给选中的根结点的双亲赋1，避免第二次查找该点return flag;}void select(HuffmanTree t,int i,int &s1,int &s2){//s1为其中序号小的int j;s1=min(t,i);s2=min(t,i);if(s1>s2){j=s1;s1=s2;s2=j;}}void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n){ // w存放n个字符的权值(均>0)，构造赫夫曼树HT，并求出n个字符的赫夫曼编码HC int m,i,s1,s2,start;unsigned c,f;HuffmanTree p;char *cd;if(n<=1)return;m=2*n-1;HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode)); // 0号单元未用for(p=HT+1,i=1;i<=n;++i,++p,++w){p->weight=*w;p->parent=0;p->lchild=0;p->rchild=0;}for(;i<=m;++i,++p)p->parent=0;for(i=n+1;i<=m;++i) // 建赫夫曼树{ // 在HT[1～i-1]中选择parent为0且weight最小的两个结点，其序号分别为s1和s2 select(HT,i-1,s1,s2);HT[s1].parent=HT[s2].parent=i;HT[i].lchild=s1;HT[i].rchild=s2;HT[i].weight=HT[s1].weight+HT[s2].weight;}// 从叶子到根逆向求每个字符的赫夫曼编码HC=(HuffmanCode)malloc((n+1)*sizeof(char*));// 分配n个字符编码的头指针向量([0]不用)cd=(char*)malloc(n*sizeof(char)); // 分配求编码的工作空间cd[n-1]='\0'; // 编码结束符for(i=1;i<=n;i++){ // 逐个字符求赫夫曼编码start=n-1; // 编码结束符位置for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)// 从叶子到根逆向求编码if(HT[f].lchild==c)cd[--start]='0';elsecd[--start]='1';HC[i]=(char*)malloc((n-start)*sizeof(char));// 为第i个字符编码分配空间strcpy(HC[i],&cd[start]); // 从cd复制编码(串)到HC }free(cd); // 释放工作空间}void main(){HuffmanTree HT;HuffmanCode HC;int *w,n,i;char ch[100][100];printf("请输入权值的个数(>1): ");scanf("%d",&n);for(i=1;i<=n;i++){printf("%d:",i);scanf("%s",&ch[i]);}w=(int*)malloc(n*sizeof(int));printf("请依次输入%d个权值(整型):\n",n);for(i=0;i<=n-1;i++)scanf("%d",w+i);printf("输出编码：\n");HuffmanCoding(HT,HC,w,n);for(i=1;i<=n;i++)printf("%s\t%s\n",&ch[i][0],&HC[i][0]);}五、程序运行界面六、实验总结列出实验中出现的问题通过此次的实验我掌握了赫夫曼树特点及其构造，以及赫夫曼编码的实现方法，这个实验也不是那么难，参照书上的代码很快就能完成。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验名称：实验六费诺编码
一、实验目的：
加深对赫夫曼编码的理解及其具体的实现过程
二、实验内容与原理：
1.完成赫夫曼的编码
2.计算平均码长及编码效率
三、实验步骤
根据赫夫曼编码的步骤完成该编码
四、实验数据及结果分析(可附程序运行截图)
编码的结果：
五、代码附录
%哈夫曼编码的MATLAB实现（基于0、1编码）：clc;
clear;
A=[0.25 0.25 0.2 0.15 0.1 0.05];%信源消息的概率序列A=fliplr(sort(A));%按降序排列
T=A;
[m,n]=size(A);
B=zeros(n,n-1);%空的编码表4*5（矩阵）
for i=1:n
B(i,1)=T(i);%生成编码表的第一列
end
r=B(i,1)+B(i-1,1);%最后两个元素相加
T(n-1)=r;
T(n)=0;
T=fliplr(sort(T));
t=n-1;%t=4
for j=2:n-1%生成编码表的其他各列
for i=1:t
B(i,j)=T(i);
end
K=find(T==r);%函数用于返回所需要元素的所在位置
B(n,j)=K(end);%从第二列开始，每列的最后一个元素记录特征元素在%该列的位置
r=(B(t-1,j)+B(t,j));%最后两个元素相加
T(t-1)=r;
T(t)=0;
T=fliplr(sort(T));
t=t-1;
end
B;%输出编码表
END1=sym('[0,1]');%给最后一列的元素编码
END=END1;
t=3;
d=1;
for j=n-2:-1:1%从倒数第二列开始依次对各列元素编码
for i=1:t-2
if i>1 & B(i,j)==B(i-1,j)
d=d+1;
else
d=1;
end
B(B(n,j+1),j+1)=-1;
temp=B(:,j+1);
x=find(temp==B(i,j));
END(i)=END1(x(d));
end
y=B(n,j+1);
END(t-1)=[char(END1(y)),'0'];
END(t)=[char(END1(y)),'1'];
t=t+1;
END1=END;
end
A%排序后的原概率序列
END%编码结果
for i=1:n
[a,b]=size(char(END(i)));
L(i)=b;
end
disp('平均码长：；');
avlen=sum(L.*A)%平均码长
H1=log2(A);
H=-A*(H1')%熵
disp('编码效率：');
P=H/avlen%编码效率
六、其他：实验总结、心得体会及对本实验方法、手段及过程的改进建议等。
哈夫曼(Huffman)编码是一种常用的压缩编码方法，是Huffman于1952年为压缩文本文件建立的。
它的基本原理是频繁使用的数据用较短的代码代替，较少使用的数据用较长的代码代替，每个数据的代码各不相同。
这些代码都是二进制码，且码的长度是可变的。