哈夫曼编码的两种实现（实验报告）

最新推荐文章于 2025-06-04 22:23:54 发布
最新推荐文章于 2025-06-04 22:23:54 发布
阅读量1.3w 收藏 72
点赞数 16
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 哈夫曼编码 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/L120305q/article/details/82793721
本文详细介绍了基于27个字符的哈夫曼编码实验过程，包括哈夫曼树的构建、编码与译码的实现，以及文件存储和读取功能。实验通过C语言完成，涉及数据结构和算法的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

数据结构的某项实验

① 问题描述：给定n个字符的权值数组w，根据哈夫曼编码与译码规则，实现一个哈夫曼编/译码系统（利用实验指导书上的27个字符的数据进行实验）。
② 利用顺序表存储Huffman树，编码结果的存储方式采用书上的结构。
③ Huffman树的构造约定如下：
根的权值较小的子树作为左子树，当权值相等时，则先生成的子树是左子树；
按照结点的生成次序选择权值较小的两棵子树构造Huffman树；
从叶子结点到根结点逆向求出每个字符的Huffman编码，不采用递归方法；
从根结点开始实现译码，要求被译码的字符数大于20个字符。
④ 采用文件方式存储n个权值和待翻译的二进制代码，其余数据均不采用文件存储。

序号 字符 权值 双亲结点 左孩子 右孩子
1 □ 186 0 0 0
2 A 64 0 0 0
3 B 13 0 0 0
4 C 22 0 0 0
5 D 32 0 0 0
6 E 103 0 0 0
7 F 21 0 0 0
8 G 15 0 0 0
9 H 47 0 0 0
10 I 57 0 0 0
11 J 1 0 0 0
12 K 5 0 0 0
13 L 32 0 0 0
14 M 20 0 0 0
15 N 57 0 0 0
16 O 63 0 0 0
17 P 15 0 0 0
18 Q 1 0 0 0
19 R 48 0 0 0
20 S 51 0 0 0
21 T 80 0 0 0
22 U 23 0 0 0
23 V 8 0 0 0
24 W 18 0 0 0
25 X 1 0 0 0
26 Y 16 0 0 0
27 Z 1 0 0 0

  1. 实验过程与结果
    完整代码：（实验环境codeblock）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//左0右1
typedef struct
   {
      unsigned int weight;
      unsigned int parent,lchild,rchild;
      char c;
      int length;
  }HTNode, *HuffmanTree;
typedef char **HuffmanCode;

void save(int n,int w[],char code[],char ch[])
{
	FILE *fp;
	char filename[20];
	int i;
	printf("请输入要保存的文件名称：\n");
	scanf("%s",filename);
	if((fp=fopen(filename,"wb"))= =NULL)//打开输出文件
	{
		printf("cannot open file：\n");
		return;
	}
	for(i=0;i<=n;i++)
	{
		if(fwrite(&w[i],sizeof(int),1,fp)!=1)//数组向磁盘文件写入各叶子节点权值
			printf("file write error!\n");
	}
	for(i=0;i<=n;i++)
    {
        if(fwrite(&ch[i],sizeof(char),1,fp)!=1)//数组向磁盘文件写入各叶子字母代表
			printf("file write error!\n");
    }
	for(i=0;i<=strlen(code);i++)
    {
      if(fwrite(&code[i],sizeof(char),1,fp)!=1)//数组向磁盘文件写入待破解电码代码
			printf("file write error!\n");
    }
	    printf("保存文件成功!!!");
	fclose(fp);
}
void read(int n,int w[],char code[],char ch[])
{
    FILE *fp;
    char filename[20];
    int i;
    printf("请输入读入的文件名:\n");
    scanf("%s",filename);
	if((fp=fopen(filename,"rb"))= =NULL)//以只读方式打开二进制文件
	{   printf("can not open file\n");
		fclose(fp);
	}
	for(i=0;i<=n;i++)
    fread(&w[i],sizeof(int),1,fp);//磁盘文件向数组读入
    for(i=0;i<=n;i++)
    fread(&ch[i],sizeof(char),1,fp);
    for(i=0;i<=strlen(code);i++)
    fread(&code[i],sizeof(char),1,fp);
    printf("读入数据成功！！！！");
    fclose(fp);
}
  void createHuffmanTree(HuffmanTree \*HT, int w[], int n,char ch[])
  {
     int m = 2 * n - 1;
     int s1,s2,i;
     \*HT = (HuffmanTree)malloc((m + 1) * sizeof(HTNode));
     for(i = 1; i <= n; i++)
     { (\*HT)[i].weight = w[i]; (\*HT)[i].lchild = 0;
          (\*HT)[i].parent = 0;(\*HT)[i].rchild = 0;
           (\*HT)[i].c=ch[i]; (\*HT)[i].length=0;
      }
     for(i = n + 1; i <= m; i++)
      {(\*HT)[i].weight = 0;(\*HT)[i].lchild = 0;
         (\*HT)[i].parent = 0;(\*HT)[i].rchild = 0;
          (\*HT)[i].c='\0'; (\*HT)[i].length=0;
     }
     printf("\n构建哈夫曼树: \n");
     for(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;
     } printf("\n");
 }
 void select(HuffmanTree \*HT, int n, int \*s1, int \*s2)
  { int i = 0,min;
      for(i = 1; i <= n; i++)
      {if((\*HT)[i].parent == 0)
          {min = i; break;
          }
      }
      for(i = 1; i <= n; i++)
     {if((\*HT)[i].parent == 0)
          { if((\*HT)[i].weight < (\*HT)[min].weight)
            { min = i;
            }
          }
      } \*s1 = min;
      for(i = 1; i <= n; i++)
      { if((\*HT)[i].parent == 0 && i != (\*s1))
          { min = i;break;
          }
     }
      for(i = 1; i <= n; i++)
      {if((\*HT)[i].parent == 0 && i != (\*s1))
          { if((\*HT)[i].weight < (\*HT)[min].weight)
              { min = i;
              }
          }   \*s2 = min;
 }
  }
//从叶子到根逆向求每个字符的哈夫曼编码
 void creatHuffmanCode(HuffmanTree HT,HuffmanCode HC,int n)
 {
     int i,j,c;
     int start;
     int f;
     HC=(HuffmanCode \*)malloc((n+1) * sizeof(char \*));//分配n个字符编码的头指针向量
     char \*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';
             else
                    cd[- -start]='1';
          }
         HC[i]=(char \*)malloc((n - start) * sizeof(char));   //为第i个字符编码分配空间
         HT[i].length=n-start-1;//求编码长度
         strcpy(HC[i],&cd[start]);
     } free(cd);//释放工作空间
     for(i = 1;i <= n; i++)
     {
         printf("权值为 %3d对应字母为  %c 的叶子节点的哈夫曼编码是 %s 长度为 %d \n", HT[i].weight,HT[i].c,HC[i],HT[i].length); }
 }
 //定义编码解码函数
void Translatecode(HuffmanTree HT,HuffmanCode HC,int n,char code[])
{  int i,j,m,c,choice;
     int start;
     int f;
     char zcode[100];//存放输入的字母字符串
     m=2*n-1;
     HC=(HuffmanCode *)malloc((n+1)*sizeof(char *));//分配n个字符编码的头指针向量
     char *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';
             else
                    cd[- -start]='1';
          }
         HC[i]=(char \*)malloc((n - start) * sizeof(char));   //为第i个字符编码分配空间
         strcpy(HC[i],&cd[start]);
     }
     while(1)
    {  printf("\n是否进行编译操作。1-执行 2-退出:\n");
            scanf("%d",&choice);
            getchar();
            if(choice=\=1)
                {   printf("请输入需要编码的字母字符串 :\n");
                gets(zcode);
                 printf("编译好的二进制编码为：\n");
                 for(i=0;zcode[i]!='\0';i++)
                 for(j=1;j<=n;j++)
                 if(HT[j].c=\=zcode[i])
                 printf("%s",HC[j]);
                }
            else  if(choice=\=2)
                 break;
    }
      while(1){  printf("\n是否进行解码操作。1-执行 2-退出\n");
            scanf("%d",&choice);
            if(choice=\=1)
                {   j=0;
                 while(code[j]!='\0')
                 {  if(code[j]=\='0')
                       m=HT[m].lchild;
                     else    m=HT[m].rchild;
                     if(HT[m].lchild=\=0)//找到叶子节点m
                   {   printf("%c",HT[m].c);
                      m=2\*n-1;//回到根节点
                   }    j++;
                }
                getchar();
                  printf("\n原电码为：\n");
                 printf("%s",code);
                printf("\n请输入已破译的电文:\n");
                      gets(zcode);
                 printf("反编译的电码为：\n");
                 for(i=0;zcode[i]!='\0';i++)
                 for(j=1;j<=n;j++)
                 if(HT[j].c=\=zcode[i])
                 printf("%s",HC[j]);
   printf("\n判断电文输入正确否  1-正确  2-错误:\n");
               scanf("%d",&choice);
                    if(choice=\=1)
                        printf("\n电文输入正确!\n");
              else  printf("\n电文输入错误!\n");  }
            else  if(choice=\=2)
                 break;}
}
//定义获取叶子节点权值和字母的函数
void getcode(char ch[],int w[],int N[]){
    int i,j,count;
    int k=1;
    char temp;
    char zcode[50];//字母字符串
    printf("请输入字母字符串：\n");
    scanf("%s",zcode);
    for(i=0;zcode[i]!='\0';i++)
    {   if(zcode[i]=='*')
          continue;
          temp=zcode[i];
          count=0;
          for(j=i;zcode[j]!='\0';j++)
           { if(temp==zcode[j])
             {   zcode[j]='*';
                count++;
             }
             ch[k]=temp;//记录叶子节点代表的字母
             w[k]=count;//权值为字母出现频率
           }
            k++;  }
    N[0]=k-1;}
 void main()
 {  HuffmanTree HT;
     HuffmanCode HC;//各叶子节点的哈夫曼编码
     char ch[30];//各叶子节点的字符代表
     char code[400]; //存放输入的二进制编码字符串
     int w[30];//w数组存储权值
     int i,j,n,m,c;
     int N[1];//当执行0号操作时，作用等价于n的值
      HC=(HuffmanCode *)malloc((n+1)*sizeof(char *));
     while(1)
     { printf("\n0-输入叶子节点个数（采用2号方法建树时使用）");  printf("\n1-输入字母字符创建哈夫曼树");//0号操作与1号操作选择一个
     printf("\n2-输入数据的权值和相应的字符代表创建哈夫曼树");
         printf("\n3-输入要破解的电文密码");
         printf("\n4-文件存储信息");
         printf("\n5-文件读取信息");
         printf("\n6-构建哈夫曼树并打印哈夫曼树");
         printf("\n7-求各叶子节点的哈夫曼编码");
         printf("\n8-进行编码译码");
         printf("\n请输入你要执行的操作:\n");
         scanf("%d",&c);
         switch(c)
         {  case 0:
             printf("输入叶子节点个数 n:  " );
                  scanf("%d",&n);
                  m=2\*n-1;
                  break;
             case 1:
                   getcode(ch,w,N);
                        n=N[0];
                       m=2\*n-1;
                  break;
             case 2:
                  printf("\n请输入%d个数据的权值:\n",n);
                  for(i=1; i<=n; i++)
                     {   printf("%d: ",i);
                       fflush(stdin);//清空输入缓存区
                       scanf("%d",&w[i]);
                     }
                  printf("请输入%d个数据的字符代表：\n",n);
                  for(i=1;i<=n;i++)
                     {  printf("%d号为: ",i);
                        fflush(stdin);//清空输入缓存区
                        scanf("%c",&ch[i]);
                      }
                break;
             case 3:
                printf("请输入要破解的电文二进制编码：\n");
                scanf("%s",code);
                break;
             case 4:
                save(n,w,code,ch);
                break;
             case 5:
                read(n,w,code,ch);
                break;
             case 6:
                createHuffmanTree(&HT,w,n,ch);
           printf("\n\*\*\**\*\*\*\*\*\*打印哈夫曼树\*\*\**\*\*\*\*\n");
     printf("序号\t字符\t权值\t双亲\t左孩子\t右孩子\n");
                for(i=1;i<=m;i++)
                printf("%d\t%c\t%d\t%d\t%d\t%d\t\n",i,HT[i].c,HT[i].weight,HT[i].parent,HT[i].lchild,HT[i].rchild);
                break;
             case 7:
                creatHuffmanCode(HT,&HC,n);
                break;
             case 8:
                Translatecode(HT,&HC,n,code);
                break;
             default: break;
         }
         if((c<0)||(c>8))
             break;
    } }

运行结果：首先进行输入节点信息并存储文件的方法构建哈夫曼树

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
由于太长只截取部分编码。完整编码为000000001010011111100000000101001111000011110110001111110101111000011001100110110111001111010000110110010011111011110110011111110010000100101110000010111101000110011

保存文件
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

关闭程序，重新开始，此时选择读取文件方式构建哈夫曼树，文件hafuman.txt中存储着各叶子节点权值，对应字符和待编译的二进制编码，读取文件截图如下，其他操作6.7.8及结果同上。
在这里插入图片描述
给出另一种构建哈夫曼树的方法

在这里插入图片描述
字母个数为相应字母对应的权值
在这里插入图片描述

其他操作同输入节点建树或者读取文件建树相似，在此不再给出。

哈夫曼编码实验报告
12-15
统计一篇文章中字母’a’~’z’（不分大小写）出现概率，对字母完成Huffman编码算法的设计与实现。
Huffman编码实验报告.doc
11-16
计算出平均码长，编码效率，信源熵. 输入一段字符序列，通过本程序可得出该字符序列中各个字符出现的次数，以及每个字符出现的概率，并能计算出信源符号熵，每个字符的哈弗曼编码，和相应的平均码长，编码效率，码方差。
霍夫曼编码详解
最新发布
06-04 975
在数据存储和传输过程中，如何高效地压缩数据以减少空间占用和传输成本----霍夫曼编码（Huffman Coding）作为一种经典的熵编码算法，能够根据数据中字符出现的频率，为每个字符分配不等长的编码，从而实现数据的无损压缩。本文我将详细介绍霍夫曼编码的原理、构建过程、代码实现、性能分析以及实际应用场景，带你深入理解这一重要算法
数据结构实验-哈夫曼编码C语言实现（实验报告内有代码和运行结果）
06-01
利用哈夫曼编码进行住处通讯可以大大提高信道利用率,缩短住处传输时间,降低成本,但是,这要求在发送端通过一个编码系统将传输的数据预先编码,在接收端通过一个译码系统对传来的数据进行译码(复原),对于双向传输信息的信道,每端都一个完整的编码译码系统,试为这样的住处收发站写一个哈夫曼友的编码译码系统.
huffman编码完整实验报告
12-30
huffman编码完整实验报告，建议不要照搬，要体会其中精髓
哈夫曼编码 实验报告
11-21
大学实验报告 哈夫曼编译码器 经过老师检查无误 数据结构C语言 严蔚敏版
山东科技大学算法设计与分析实验5：实现哈夫曼编码 源.cpp+报告
07-20
实验报告可能会详细讨论这些方面，包括算法的实现细节、性能测试结果、复杂性分析以及可能的优化策略。此外，报告可能还会强调理解哈夫曼编码背后的理论和实践应用的重要性，鼓励学生深入思考和实践。 总之，哈夫曼...
信息论实验报告(实验四、哈夫曼编码)
06-09
信息论实验报告（哈夫曼编码）展示了哈夫曼编码的原理和实现方法，并对给定信源进行了香农编码和编码效率的计算。实验结果表明，哈夫曼编码方法可以有效地压缩信源信息，提高通信系统的性能。本实验报告为相关领域的...
哈夫曼编码（贪心算法）报告.doc
12-26
哈夫曼编码是一种基于贪心策略的高效数据文件压缩编码方法，其核心在于通过构建最优前缀码来实现编码效率的最大化。在本实验报告中，我们将深入理解哈夫曼编码的工作原理、设计思想以及其实现过程。 1. 问题描述： ...
哈夫曼编码实验报告.docx
12-03
【哈夫曼编码实验报告】 本实验主要涉及的是哈夫曼编码（Huffman Coding）这一数据压缩技术，它是基于频率的变长编码方法，广泛应用于数据压缩领域。实验旨在通过编程实现对文本文件的加解密和压缩，利用哈夫曼树的...
用哈夫曼编码实现文件压缩实验报告.pdf
11-13
《用哈夫曼编码实现文件压缩》实验报告主要探讨了如何使用哈夫曼编码技术来压缩文件，尤其针对小写英文字母的文本。实验旨在让学习者掌握多个与计算机科学相关的概念和技术，包括文件的基本理解、线性链表操作、...
哈夫曼编码译码器实验报告（内附源代码）
12-27
哈夫曼编码译码器实验报告，内有源代码，vc++6.0写的
数据结构哈夫曼编码实验报告.doc
07-11
数据结构实验报告 ―― 实验五 简单哈夫曼编/译码的设计与实现 本实验的目的是通过对简单哈夫曼编/译码系统的设计与实现来熟练掌握树型结构在 实际问题中的应用。此实验可以作为综合实验，阶段性实验时可以选择其中的几个功能 来设计和实现。 一、【问题描述】 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本 。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数 据进行译码，此实验即设计这样的一个简单编/码系统。系统应该具有如下的几个功能： 1、接收原始数据。 从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件nod edata.dat中。 2、编码。 利用已建好的哈夫曼树（如不在内存，则从文件nodedata.dat中读入），对文件中的正 文进行编码，然后将结果存入文件code.dat中。 3、译码。利用已建好的哈夫曼树将文件code.dat中的代码进行译码，结果存入文件tex tfile.dat中。 4、打印编码规则。 即字符与编码的一一对应关系。 二、【数据结构设计】 1、构造哈夫曼树时使用静态链表作为哈夫曼树的
数据结构哈夫曼编码实验报告
01-02
利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码
哈夫曼编码 实践报告
12-29
（1）利用字符集中每个字符的使用频率作为权值构造一个赫夫曼树； （2）从根结点开始，为到每个叶子结点路径上的左分支赋予 0，右分支赋予1， 并从根到叶子方向形成该叶子结点的编码。
哈夫曼编码的实验报告
热门推荐
niannianxi的博客
11-28 2万+
哈夫曼编码实验报告 一、实验目的         通过哈夫曼编、译码算法的实现，巩固二叉树及哈夫曼树相关知识的理解掌握，训练学生运用所学知识，解决实际问题的能力。 二.实验内容         已知每一个字符出现的频率，构造哈夫曼树，并设计哈夫曼编码。 基本要求： （1）从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树； （2）打印每一个
哈夫曼编码编译器c语言实训,C语言-哈夫曼编码实验报告
weixin_31572175的博客
05-18 591
《C语言-哈夫曼编码实验报告》由会员分享，可在线阅读，更多相关《C语言-哈夫曼编码实验报告(12页珍藏版)》请在人人文库网上搜索。1、C语言 - 哈夫曼编码实验报告福建工程学院课程设计课程：数据结构题目：哈夫曼编码和译码专业：信息管理信息系统班级：1002 班座号：15 号姓名：林左权2011 年6 月27 日2实验题目：哈夫曼编码和译码一、要解决的问题利用哈夫曼编码进行信息通信可以大大提高信道利...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值