信息论实验报告(实验四、哈夫曼编码)
哈夫曼实验报告实验目的(3篇)
6. 对压缩数据进行解压缩，验证哈夫曼编码的正确性。
7. 分析实验结果，对比压缩前后数据的差异。
五、实验总结
通过本次实验，我们掌握了哈夫曼编码的原理和构造方法，学会了如何使用哈夫曼编码进行数据压缩和解压缩。实验结果表明，哈夫曼编码能够有效降低数据的冗余，提高数据压缩效果。同时，本次实验也加深了我们对数据结构中树形结构及其应用的理解，提高了算法设计和实现能力。在今后的学习和工作中，我们将继续探索哈夫曼编码及其应用，为相关领域的研究和发展贡献自己的力量。
二、实验内容
1. 理解哈夫曼编码的原理，掌握哈夫曼树的构造方法。
2. 编写程序实现哈夫曼树的构建、编码和解码过程。
3. 对给定的字符集进行哈夫曼编码，并分析编码后的结果。
4. 对编码后的数据进行解码，验证解码结果的正确性。
5. 比较哈夫曼编码与其他编码方法在数据压缩方面的性能。
三、实验原理
哈夫曼编码是一种基于字符频率的变长编码方法。在哈夫曼编码中，每个字符都被赋予一个唯一的编码，编码的长度与其在原始数据中的频率成反比。频率高的字符编码较短，频率低的字符编码较长。这样，哈夫曼编码在保证数据完整性的同时，实现了数据压缩的目的。
2. 能够编写程序实现哈夫曼编码和解码，提高编程能力。
3. 分析哈夫曼编码在不同场景下的压缩效果，为实际应用提供参考。
4. 了解哈夫曼编码在实际应用中的优势和局限性，为解决实际问题提供思路。
5. 培养实验操作能力，提高解决实际问题的能力。
通过本次实验，我们希望学员能够全面掌握哈夫曼编码的原理、构造方法及其在实际应用中的价值，为今后的学习和工作打下坚实的基础。
第2篇
一、实验目的
1. 理解哈夫曼编码的原理及其在数据压缩中的应用。
《哈夫曼编码》实验报告
《哈夫曼编码》实验报告《哈夫曼编码》实验报告一、实验目的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. 生成编码表通过遍历哈夫曼树，我们可以得到每个字符对应的编码。
在遍历过程中，我们记录下每个字符的路径，左边走为0，右边走为1，从而生成编码表。
4. 进行编码和解码在得到编码表后，我们可以将原始文本进行编码，将每个字符替换为对应的编码。
编码后的文本长度将会大大减少。
为了验证编码的正确性，我们还需要进行解码，将编码后的文本还原为原始文本。
四、实验结果我们选取了一段英文文本作为实验数据，并进行了哈夫曼编码。
经过编码后，原始文本长度从1000个字符减少到了500个字符。
解码后的文本与原始文本完全一致，验证了哈夫曼编码的正确性。
五、讨论与总结哈夫曼编码作为一种高效的信息压缩算法，具有广泛的应用前景。
通过将出现频率较高的字符用较短的编码表示，哈夫曼编码可以在一定程度上减小信息的存储和传输成本。
然而，哈夫曼编码也存在一些局限性，例如对于出现频率相近的字符，编码长度可能会相差较大。
信息论霍夫曼编码译码实验报告
实验一一、实验背景*哈夫曼编码(Huffman Coding)是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。
Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般叫作Huffman编码。
二、实验要求*利用程序实现哈夫曼编码，以加深对哈夫曼编码的理解，并锻炼编程能力。
三、代码分析#include<stdio.h>#define n 3 //叶子数目#define m (2*n-1) //结点总数#define maxval 10000.0 //maxval是float类型的最大值#define maxsize 100 //哈夫曼编码的最大位数typedef struct //定义霍夫曼树结构体{char ch; //消息float weight; //所占权重int lchild,rchild,parent; //定义左孩子、右孩子}hufmtree;typedef struct //定义霍夫曼编码结构体{char bits[n]; //位串int start; //编码在位串中的起始位置char ch; //字符}codetype;void huffman(hufmtree tree[]); //建立哈夫曼树void huffmancode(codetype code[],hufmtree tree[]); //根据哈夫曼树求出哈夫曼编码void decode(hufmtree tree[]); //依次读入电文，根据哈夫曼树译码void main(){printf(" ——哈夫曼编码——\n");printf("信源共有%d个符号\n",n);hufmtree tree[m]; //m个结点，即有m个树形结构codetype code[n]; //信源有n个消息，则需要n个编码int i,j; //循环变量huffman(tree); //建立哈夫曼树huffmancode(code,tree); //根据哈夫曼树求出哈夫曼编码printf("【输出每个字符的哈夫曼编码】\n");for(i=0;i<n;i++){printf("%c: ",code[i].ch);for(j=code[i].start;j<n;j++)printf("%c ",code[i].bits[j]);//“消息：该消息的编码”printf("\n");}printf("【读入电文，并进行译码】\n");decode(tree); //依次读入电文，根据哈夫曼树译码}void huffman(hufmtree tree[]) //建立哈夫曼树{int i,j,p1,p2; //p1,p2分别记住每次合并时权值最小和次小的两个根结点的下标float small1,small2,f;char c;for(i=0;i<m;i++) //初始化{tree[i].parent=0;tree[i].lchild=-1;tree[i].rchild=-1;tree[i].weight=0.0;}printf("【依次读入前%d个结点的字符及权值(中间用空格隔开)】\n",n);for(i=0;i<n;i++) //读入前n个结点的字符及权值{printf("输入第%d个字符为和权值",i+1);scanf("%c %f",&c,&f);getchar(); //吸收回车符tree[i].ch=c;tree[i].weight=f; //将接收到的结点的字符及权值存入它对应的结构体数据中}for(i=n;i<m;i++) //进行n-1次合并，产生n-1个新结点{p1=0;p2=0;small1=maxval;small2=maxval; //maxval是float类型的最大值for(j=0;j<i;j++) //选出两个权值最小的根结点{if(tree[j].parent==0) //还未找到父结点的if(tree[j].weight<small1) //如果有比最小的还小的{small2=small1; //改变最小权、次小权及对应的位置small1=tree[j].weight;p2=p1;p1=j;}else if(tree[j].weight<small2) //如果有比最小的大，但比第二小的小的{small2=tree[j].weight; //改变次小权及位置p2=j;}}//找出的两个结点是新节点i的两个孩子tree[p1].parent=i;tree[p2].parent=i;tree[i].lchild=p1; //最小权根结点是新结点的左孩子tree[i].rchild=p2; //次小权根结点是新结点的右孩子tree[i].weight=tree[p1].weight+tree[p2].weight;}} //huffman//codetype code[]为求出的哈夫曼编码//hufmtree tree[]为已知的哈夫曼树void huffmancode(codetype code[],hufmtree tree[]) //根据哈夫曼树求出哈夫曼编码{int i,c,p;codetype cd; //缓冲变量for(i=0;i<n;i++){cd.start=n; //编码在位串中的起始位置cd.ch=tree[i].ch;c=i; //从叶结点出发向上回溯，第i个叶结点p=tree[i].parent; //tree[p]是tree[i]的父结点while(p!=0){cd.start--;if(tree[p].lchild==c)cd.bits[cd.start]='0'; //tree[i]是左子树，生成代码'0' elsecd.bits[cd.start]='1'; //tree[i]是右子树，生成代码'1' c=p; //c记录此时的父结点p=tree[p].parent; //p记录新的父结点，即原来的父结点的父结点，向上溯回}code[i]=cd; //第i+1个字符的编码存入code[i] }} //huffmancodevoid decode(hufmtree tree[])//依次读入电文，根据哈夫曼树译码{int i,j=0;char b[maxsize];i=m-1; //从根结点开始往下搜索printf("输入发送的编码：");gets(b);printf("译码后的字符为");while(b[j]!='\0'){if(b[j]=='0')i=tree[i].lchild; //走向左子树elsei=tree[i].rchild; //走向右子树if(tree[i].lchild==-1) //如果回到叶结点，则把该结点的消息符号输出{printf("%c",tree[i].ch);i=m-1; //回到根结点}j++;}printf("\n");if(tree[i].lchild!=-1&&b[j]=='\0') //电文读完，但尚未到叶子结点printf("\nERROR\n"); //输入电文有错}//decode四、实验补充说明解码时，以回车键结束输入电文。
哈夫曼编码实验报告
一、实验目的1．掌握MATLAB软件的使用，以及其设计流程；2．掌握哈夫曼编码的实现方法；3．用MATLAB语言设计哈夫曼编码的实现方法。
4．提高独立进行算法编程的能力。
二、实验仪器或设备装MATLAB软件的微机一台三、总体设计1、二进制Huffman编码的基本原理及算法1).将信源消息符号按其出现的概率大小依次排列为12...np p p≥≥≥2).取两个概率最小的字母分别配以0和1两个码元，并将这两个概率相加作为一个新字母的概率，与未分配的二进制符号的字母重新排队。
3).对重排后的两个概率最小符号重复步骤2的过程。
4).不断继续上述过程，直到最后两个符号配以0和1为止。
5).从最后一级开始，向前返回得到各个信源符号所对应的码元序列，即相应的码子。
2、程序设计的原理1)程序的输入：以一维数组的形式输入要进行huffman编码的信源符号的概率，在运行该程序前，显示文字提示信息，提示所要输入的概率矢量；然后对输入的概率矢量进行合法性判断，原则为：如果概率矢量中存在小于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列的值等于对应于a矩阵中第n-i+1行中值为j+1的前面一个元素的位置在c矩阵中的编码值”的原则进行赋值，重复以上过程即可完成huffman编码。
信息论课程实验报告—哈夫曼编码
*p2 = j;
}
}
void CreateHuffmanTree(HuffmanTree T)
{
int i,p1,p2;
InitHuffmanTree(T);
InputWeight(T);
for(i = n;i < m;i++)
4）依次继续下去，直至信源最后只剩下两个信源符号为止，将这最后两个信源符号分别用二元码符号“0”和“1”表示；
5）然后从最后—级缩减信源开始，进行回溯，就得到各信源符号所对应的码符号序列，即相应的码字。
四、实验目的：
(1)进一步熟悉Huffman编码过程；(2)掌握C语言递归程序的设计和调试技术。以巩固课堂所学编码理论的知识。
#include "stdio.h"
#include "stdlib.h"
#include <float.h>
#include <math.h>
#define n 8
#define m 2*n-1
typedef struct
{
float weight;
int lchild,rchild,parent;
}
}
void InputWeight(HuffmanTree T)
{
float temp[n] = {0.20,0.18,0.17,0.15,0.15,0.05,0.05,0.05};
for(int i = 0;i < n;i++)
T[i].weight = temp[i];
}
哈夫曼编码实验报告
赫夫曼编码实验报告一、实验内容实现赫夫曼编码的算法二、哈夫曼编码的实验步骤1．输入n个信源符号及其对应的权值2．利用select()函数找出权值最小的两个信源，并各自分配一个码元“0”“1”，并将这两个信源合并为一个新的信源，其权值为这两个最小信源的权值之和，得到一个包n-1个信源符号的新信源，这一过程叫做信源的第一次缩减3.重复步骤二，直到只剩下两个符号为止，此时从最后一级缩减信源开始，依编码路经向前返回，得到各信源符号所对应的码字4.输出信息熵，平均码长以及编码效率三、源代码#include<iostream>#include <math.h>using namespace std;#define MAX 100typedef struct{int weight;int parent,Lc,Rc;char data;}HTNode,*HTree; //动态分配数组存储赫夫曼树typedef char * *HCode;void HuffmanCode(HTree &HT,HCode &HC,int *w,int n);void Select(HTree &HT,int n,int &s1,int &s2);void inputCode();void outputCode(HCode HC,char *data,int *w,int n);const int n=27;int flag=0;HTree Ht;HCode Hc;int num;void HuffmanCode(HTree &HT,HCode &HC,int *w,int n){//w存放n个字符权值(均>0)，构造赫夫曼树HT，并求n个字符赫夫曼编码HC。
int m,i,s1,s2;//s1,s2为在HT[1..i-1]中parent为0且weight最小的两个结点if(n<=1) return;//如果结点小于或等于1个，则调用函数出错，退出函数m=2*n-1;//m为赫夫曼树的总结点数HT=(HTree)malloc((m+1)*sizeof(HTNode));// 对赫夫曼树进行初始化for(i=1;i<=n;i++) {HT[i].data=0;HT[i].weight=w[i-1];HT[i].parent=0;HT[i].Lc=0;HT[i].Rc=0;}for(;i<=m;i++) {HT[i].data=0;HT[i].weight=0;HT[i].parent=0;HT[i].Lc=0;HT[i].Rc=0;}//***************创建HuffmanTree******************char *cd;int start,c,f;for(i=n+1;i<=m;++i){Select(HT,i-1,s1,s2);HT[s1].parent=HT[s2].parent=i;HT[i].Rc=s2;HT[i].weight=HT[s1].weight+HT[s2].weight;}//从叶子到根逆向求每个字符的赫夫曼编码HC=(HCode)malloc((n+1)*sizeof(char*)); //分配n个字符编码的头指针向量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].Lc==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);}//HuffmanCode//s1为权值最小的根结点void Select(HTree &HT,int n,int &s1,int &s2){//在HT[1..n]选择parent为0且weight最小的两个结点，其序号分别为s1,s2。
信息论实验报告(实验四、哈夫曼编码)
3、把这个合成概率看成是一个新组合符号地概率，重复上述做法直到最后只剩下两个符号概率为止；
4、完成以上概率顺序排列后，再反过来逐步向前进行编码，每一次有二个分支各赋予一个二进制码，可以对概率大的赋为零，概率小的赋为1；
5、从最后一级开始，向前返回得到各个信源符号所对应的码元序列，即相应的码字。
“1”，小的概率赋“0”。
（3）从最后一级开始，向前返回得到各个信源符号所对应的码元序列，即相应的码字。
（4）计算码字的平均码长得出最后的编码效率。
五、实验数据记录
六、实验结论与心得
通过本次实验，加强了对matlab程序的学习，进一步提高了我的编程能力。
如有侵权请联系告知删除，感谢你们的配合！
学生实验报告
院别
电子工程学院
课程名称
信息论与编码
班级
实验名称
实验四、哈夫曼编码
姓名
实验时间
学号
指导教师
成绩
报 告 内 容
一、实验目的和任务
1、理解信源编码的意义；
2、熟悉MATLAB程序设计；
3、掌握哈夫曼编码的方法及计算机实现；
４、对给定信源进行香农编码，并计算编码效率；
二、实验原理介绍
1、把信源符号按概率大小顺序排列，并设法按逆次序分配码字的长度；
三、实验设备介绍
1、计算机
2、编程软件MATLAB6.5以上
四、实验内容和步骤
对如下信源进行哈夫曼编码，并计算编码效率。
（1）计算该信源的信源熵，并对信源概率进行排序
（2）首先将出现概率最小的两个符号的概率相加合成一个概率，把这个合成概率与其他的概率进行组合，得到一个新的概率组合，重复上述做法，直到只剩下两个概率为止。之后再反过来逐步向前进行编码，每一次有两个分支各赋予一个二进制码。对大的概率赋
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）在哈弗曼编码的过程中，对缩减信源符号按概率有大到小的顺序重新排列，应使合并后的新符号尽可能排在靠前的位置，这样可使合并后的新符号重复编码次数减少，使短码得到充分利用。
实验四、哈夫曼编码
实验四、哈夫曼编码问题描述与实验目的：给定n个字母（或字）在文档中出现的频率序列X=<x1,x2,…,xn>，求出这n个字母的Huffman编码。
为方便起见，以下将频率用字母出现的次数（或称权值）w 1,w2,…,wn代替。
输入输入文件中的开始行上有一个整数T，（0<T<=20），表示有T组测试数据。
接下来是T行测试数据的描述，每组测试数据有2行。
测试数据的第1行上是一个正整数n，（n<50），表示序列的长度。
第2行是n个字母出现的权值序列w 1,w2,…,wn，它们均为正整数，相邻的两个整数之间用空格隔开。
输入直到文件结束。
输出对输入中的每组有n个权值的数据，应输出n+1行：先在一行上输出“Case #”，其中“#”是测试数据的组号（从1开始）；接下来输出n行，其第1行到第n行上依次输出第i个字母出现的次数和相应的Huffman编码，格式如下：wi Huffman编码。
每组测试数据对应的输出最后结束时加一个空行，以便区分。
为保证Huffman编码的唯一性，在构造Huffman树的过程中，我们约定：1．左儿子标记为0，右儿子标记为1；2．左儿子的权值>=右儿子的权值；3．相同权值w的两个字母x、y，先输入权值的字母x的Huffman编码长度不超过后输入权值的字母y的Huffman编码长度。
4．合并两个节点后新的权值应从右到左搜索、插入到相应的位置。
例如：输入权值序列8 9 3 4 1 2，其Huffman编码求解过程如下，参考图A-J：8 9 3 4 1 2图 A38 9 4 3 2 1图 C 6 3 9 8 4 3 2 1图 D 8 9 4 3 2 1图 B 6 3 9 8 3 2 1 4图 E106 3 9 8 3 2 1 4图 F 10633 2 14 9 8图 G106 3 17 3 2 1 4 9 8图 H10 6 17 3 9 8 3 2 1 4图 I2710 6 17 39 8 3 2 1 4图 J注意，如图C 中权值1、2对应的节点合并后得权值为3的新节点，它插入到权值为3的原有节点的右边。
哈夫曼编码译码器实验报告
哈夫曼编码译码器实验报告实验名称：哈夫曼编码译码器实验一、实验目的：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.比较编码前后字符串的内容，结果正确。
五、实验总结：通过本次实验，我了解了哈夫曼编码的原理和应用，并且实现了一个简单的哈夫曼编码的编码和译码器。
在实验过程中，我充分运用了数据结构中的树的知识，构建了一个哈夫曼树，并生成了编码表。
通过编码和译码过程，我进一步巩固了对树的遍历和节点查找的理解。
实验结果表明，本次哈夫曼编码的编码和译码过程正确无误。
在实验的过程中，我发现哈夫曼编码对于频率较高的字符具有较短的编码，从而实现了对字符串的高效压缩。
同时，哈夫曼编码还可以应用于数据传输和存储中，提高数据的传输效率和存储空间的利用率。
通过本次实验，我不仅掌握了哈夫曼编码的编码和译码过程，还深入了解了其实现原理和应用场景，加深了对数据结构和算法的理解和应用能力。
哈夫曼编码 实验报告
哈夫曼编码实验报告哈夫曼编码实验报告一、引言哈夫曼编码是一种用于数据压缩的算法，由大卫·哈夫曼于1952年提出。
它通过将出现频率高的字符用较短的编码表示，从而实现对数据的高效压缩。
本实验旨在通过实际操作和数据分析，深入了解哈夫曼编码的原理和应用。
二、实验目的1. 掌握哈夫曼编码的基本原理和算法；2. 实现哈夫曼编码的压缩和解压缩功能；3. 分析不同数据集上的压缩效果，并对结果进行评估。
三、实验过程1. 数据集准备本实验选取了三个不同的数据集，分别是一篇英文文章、一段中文文本和一段二进制数据。
这三个数据集具有不同的特点，可以用来评估哈夫曼编码在不同类型数据上的压缩效果。
2. 哈夫曼编码实现在实验中，我们使用了Python编程语言来实现哈夫曼编码的压缩和解压缩功能。
首先，我们需要统计数据集中各个字符的出现频率，并构建哈夫曼树。
然后，根据哈夫曼树生成每个字符的编码表，将原始数据转换为对应的编码。
最后，将编码后的数据存储为二进制文件，并记录编码表和原始数据的长度。
3. 压缩效果评估对于每个数据集，我们比较了原始数据和压缩后数据的大小差异，并计算了压缩比和压缩率。
压缩比是指压缩后数据的大小与原始数据大小的比值，压缩率是指压缩比乘以100%。
通过对比不同数据集上的压缩效果，我们可以评估哈夫曼编码在不同类型数据上的性能。
四、实验结果与分析1. 英文文章数据集对于一篇英文文章，经过哈夫曼编码压缩后，我们发现压缩比为0.6，即压缩后的数据只有原始数据的60%大小。
这说明哈夫曼编码在英文文本上具有较好的压缩效果。
原因在于英文文章中存在大量的重复字符，而哈夫曼编码能够利用字符的出现频率进行编码，从而减少数据的存储空间。
2. 中文文本数据集对于一段中文文本，我们发现哈夫曼编码的压缩效果不如在英文文章上的效果明显。
压缩比为0.8，即压缩后的数据只有原始数据的80%大小。
这是因为中文文本中的字符种类较多，并且出现频率相对均匀，导致哈夫曼编码的优势减弱。
哈夫曼编码实验报告
哈夫曼编码实验报告①问题描述：给定n个字符的权值数组w，根据哈夫曼编码与译码规则，实现一个哈夫曼编/译码系统（利用实验指导书上的27个字符的数据进行实验）。
②利用顺序表存储Huffman树，编码结果的存储方式采用书上的结构。
③Huffman树的构造约定如下：根的权值较小的子树作为左子树，当权值相等时，则先生成的子树是左子树；按照结点的生成次序选择权值较小的两棵子树构造Huffman树；从叶子结点到根结点逆向求出每个字符的Huffman编码，不采用递归方法；从根结点开始实现译码，要求被译码的字符数大于20个字符。
④采用文件方式存储n个权值和待翻译的二进制代码，其余数据均不采用文件存储。
序号字符权值双亲结点左孩子右孩子1 □186 0 0 02 A 64 0 0 03 B 13 0 0 04 C 22 0 0 05 D 32 0 0 06 E 103 0 0 07 F 21 0 0 08 G 15 0 0 09 H 47 0 0 010 I 57 0 0 011 J 1 0 0 012 K 5 0 0 013 L 32 0 0 014 M 20 0 0 015 N 57 0 0 016 O 63 0 0 017 P 15 0 0 018 Q 1 0 0 019 R 48 0 0 020 S 51 0 0 021 T 80 0 0 022 U 23 0 0 023 V 8 0 0 024 W 18 0 0 025 X 1 0 0 026 Y 16 0 0 027 Z 1 0 0 0实验过程与结果完整代码：（实验环境codeblock）关闭程序，重新开始，此时选择读取文件方式构建哈夫曼树，文件hafuman.txt中存储着各叶子节点权值，对应字符和待编译的二进制编码，读取文件截图如下，其他操作6.7.8及结果同上。
信息论与编码实验四
信息论与编码实验四
实验4huffman编码对英文文本的压缩和解压缩
一、实验内容
根据信源放大编码――huffman编码的原理，制作对英文文本展开放大和解压缩的软件。
建议软件存有直观的用户界面，软件能对运转的状态分解成报告，分别就是：字符频率统计数据报告、编码报告、放大程度信息报告、码表存储空间报告。
二、实验环境
1.计算机
2.windows2000或以上
3.microsoftoffice2000或以上
4.vc++6.0三、实验目的
1.掌握huffman编码的原理
2.掌控vc研发环境的采用（尤其就是程序调试技巧）
3.掌控c语言编程（尤其就是位运算和文件的操作方式）
4.掌控数据结构的内容：链表、顺序表中、堆栈、最优二叉树
5.掌控结构化程序分析和研发的软件工程原理四、实验建议
1.提前预习实验，认真阅读实验原理。
2.深入细致高效率的顺利完成实验，实验过程中顺从实验室管理人员以及实验指导旧
师的管理。
3.深入细致核对实验报告。
五、实验原理
压缩/解压缩流程
放大流程：
读取扫描文本文件――〉统计字符频率――〉生成码字――〉保存压缩文件解压缩流程：
加载读取压缩文件――〉抽取字符频率――〉分解成码树――〉留存文本文件六、参考书
1.《信息论――基础理论及应用》傅祖芸，电子工业出版社
2.《数据结构》，清华大学出版社。
哈夫曼编码实验报告
实验报告与总结一、实验目的1、掌握哈夫曼编码原理；2、熟练掌握哈夫曼树的生成方法；3、理解数据编码压缩和译码输出编码的实现。
二、实验要求实现哈夫曼编码和译码的生成算法。
三、实验内容先统计要压缩编码的文件中的字符字母出现的次数，按字符字母和空格出现的概率对其进行哈夫曼编码，然后读入要编码的文件，编码后存入另一个文件；接着再调出编码后的文件，并对其进行译码输出，最后存入另一个文件中。
五、实验原理1、哈夫曼树的定义：假设有n个权值，试构造一颗有n个叶子节点的二叉树，每个叶子带权值为wi，其中树带权路径最小的二叉树成为哈夫曼树或者最优二叉树；2、哈夫曼树的构造：weight为输入的频率数组，把其中的值赋给依次建立的HT Node对象中的data属性，即每一个HT Node对应一个输入的频率。
然后根据data属性按从小到大顺序排序，每次从data取出两个最小和此次小的HT Node，将他们的data相加，构造出新的HTNode作为他们的父节点，指针parent，leftchild，rightchild赋相应值。
在把这个新的节点插入最小堆。
按此步骤可以构造构造出一棵哈夫曼树。
通过已经构造出的哈夫曼树，自底向上，由频率节点开始向上寻找parent,直到parent 为树的顶点为止。
这样，根据每次向上搜索后，原节点为父节点的左孩子还是右孩子，来记录1或0，这样，每个频率都会有一个01编码与之唯一对应，并且任何编码没有前部分是同其他完整编码一样的。
六、实验流程①初始化，统计文本文件中各字符的个数作为权值,生成哈夫曼树；②根据符号概率的大小按由大到小顺序对符号进行排序；③把概率最小的两个符号组成一个节点；④重复步骤（2）（3），直到概率和为1；⑤从根节点开始到相应于每个符号的“树叶”，概率大的标“0”，概率小的标“1”；⑥从根节点开始，对符号进行编码；⑦译码时流程逆向进行，从文件中读出哈夫曼树,并利用哈夫曼树将编码序列解码。
哈夫曼编码译码实训报告
一、实训目的本次实训旨在通过实际操作，使学生掌握哈夫曼编码的基本原理和方法，熟悉哈夫曼树的构建过程，并能够熟练地进行哈夫曼编码和译码操作。
通过实训，提升学生对数据压缩技术的理解和应用能力。
二、实训内容1. 哈夫曼树构建- 收集给定字符串中每个字符的出现频率。
- 根据字符频率构建哈夫曼树，其中频率高的字符对应较大的权重。
- 使用优先队列（最小堆）实现哈夫曼树的构建。
2. 哈夫曼编码- 遍历哈夫曼树，为每个叶子节点分配唯一的编码，左分支为0，右分支为1。
- 根据分配的编码生成字符编码表。
3. 哈夫曼译码- 使用生成的编码表，将编码字符串转换回原始字符串。
三、实训步骤1. 数据准备- 选择一段英文或中文文本作为输入数据。
2. 构建哈夫曼树- 统计输入数据中每个字符的出现频率。
- 使用优先队列构建哈夫曼树。
3. 生成哈夫曼编码- 遍历哈夫曼树，为每个叶子节点分配编码。
- 生成字符编码表。
4. 编码数据- 使用哈夫曼编码表对输入数据进行编码。
5. 译码数据- 使用哈夫曼编码表对编码后的数据进行译码。
6. 结果分析- 比较编码前后数据的大小，分析哈夫曼编码的压缩效果。
四、实训结果1. 哈夫曼树构建- 成功构建了给定字符串的哈夫曼树。
2. 哈夫曼编码- 成功生成了每个字符的哈夫曼编码。
3. 哈夫曼译码- 成功将编码后的数据译码回原始字符串。
4. 压缩效果分析- 通过对比编码前后数据的大小，验证了哈夫曼编码的压缩效果。
五、实训总结1. 哈夫曼编码原理- 哈夫曼编码是一种基于字符频率的变长编码方法，能够有效降低数据传输的冗余度。
2. 哈夫曼树构建- 哈夫曼树的构建是哈夫曼编码的关键步骤，通过优先队列（最小堆）实现。
3. 哈夫曼编码与译码- 哈夫曼编码和译码过程相对简单，但需要正确处理编码表和字符编码。
4. 实训收获- 通过本次实训，掌握了哈夫曼编码的基本原理和方法，熟悉了哈夫曼树的构建过程，并能够熟练地进行哈夫曼编码和译码操作。
综合实验四 哈夫曼码编、译码器的实现
综合实验四哈夫曼码编、译码器的实现一、实验名称哈夫曼码编、译码器的实现二、实验目的1、熟练哈夫曼树的定义，掌握构造哈夫曼树的方法。
2、掌握哈夫曼编码和译码方法。
3、掌握文本文件的读写方法。
三、实验内容1、实验内容：利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。
但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码。
对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编码、译码系统。
试为这样的信息收发站写一个哈夫曼码的编码、译码系统。
一个完整的系统应以下功能:(1) 从终端读入字符集大小n，以及n个字符和n个权值,建立哈夫曼树,并将它存放在文件hfmTree中。
(2) 利用已建立好的哈夫曼树（如不在内存，则从文件hfmTree中读入），对文件ToBeTran 中的正文进行编码,然后将结果代码存(传输)到文件CodeFile中.(3) 译码(Decoding)。
利用已建好的哈夫曼树,对传输到达的CodeFile中的数据代码进行译码,将译码结果存入文件TextFile。
(4) 将文件CodeFile以紧凑格式显示在终端上，每行50个代码。
同时将此字符形式的编码文件写入文件CodePrin中。
(5) 打印印哈夫曼树(TreePrinting)。
将已在内存中的哈夫曼树以直观的方式(树或凹入表的形式)显示在终端上，同时将此字符形式的哈夫曼树写入文件TreePrint中。
(6)数据结构设计根据下面给出的存储结构定义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中的数据代码进行译码,//将译码结果存入文件textFile中2、实验要求（1）、用C语言编程实现上述实验内容中的结构定义和算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
（4）计算码字的平均码长得出最后的编码效率。
五、实验数据记录
六、实验结论与心得
通过本次实验，加强了对matlab程序的学习，进一步提高了我的编程能力。
学生实验报告
院别
电子工程学院
课程名称
信息论与编码
班级
实验名称
实验四、哈夫曼编码
姓名
实验时间
学号
指导教师
成绩
报 告 内 容
一、实验目的和任务
1、理解信源编码的意义；
2、熟悉MATLAB程序设计；
3、掌握哈夫曼编码的方法及计算机实现；
４、对给定信源进行香农编码，并计算编码效率；
二、实验原理介绍
1、把信源符号按概率大小顺序排列，并设法按逆次序分配码字的长度；
三、实验设备介绍
1、计算机
2、编程软件MATLAB6.5以上
四、实验内容和步骤
对如下信源进行哈夫曼编码，并计算编码效率。
（1）计算该信源的信源熵，并对信源概率进行排序
（2）首先将出现概率最小的两个符号的概率相加合成一个概率，把这个合成概率与其他的概率进行组合，得到一个新的概率组合，重复上述做法，直到只剩下两个概率为止。之后再反过来逐步向前进行编码，每一次有两个分支各赋予一个二进制码。对大的概率赋“1”，小的概率赋“0”。
2、在分配码字长度时，首先将出现概率最小的两个符号的概率相加合成一个概率；
3、把这个合成概பைடு நூலகம்看成是一个新组合符号地概率，重复上述做法直到最后只剩下两个符号概率为止；
4、完成以上概率顺序排列后，再反过来逐步向前进行编码，每一次有二个分支各赋予一个二进制码，可以对概率大的赋为零，概率小的赋为1；
5、从最后一级开始，向前返回得到各个信源符号所对应的码元序列，即相应的码字。