实验六_赫夫曼编码
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编码。
- 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年为压缩文本文件建立的。
它的基本原理是频繁使用的数据用较短的代码代替，较少使用的数据用较长的代码代替，每个数据的代码各不相同。
这些代码都是二进制码，且码的长度是可变的。