数据结构哈夫曼树实现26个英文字符的编码和译码

最新推荐文章于 2023-09-04 21:44:31 发布
置顶 最新推荐文章于 2023-09-04 21:44:31 发布
阅读量1.4w 收藏 218
点赞数 46
分类专栏： 完美 牛逼 真厉害 文章标签： C语言 哈夫曼树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hold_twenty/article/details/95602451
版权
牛逼 同时被 3 个专栏收录
1 篇文章 0 订阅
订阅专栏
真厉害
1 篇文章 0 订阅
订阅专栏
完美
0 篇文章 0 订阅
订阅专栏

数据结构哈夫曼树实现26英文字符的编码和译码

那么首先什么是哈夫曼树？（知道的略过，直奔下面代码就好！）

在这里插入图片描述

在计算机数据处理中，霍夫曼编码使用变长编码表对源符号（如文件中的一个字母）进行编码，其中变长编码表是通过一种评估来源符号出现机率的方法得到的，出现机率高的字母使用较短的编码，反之出现机率低的则使用较长的编码，这便使编码之后的字符串的平均长度、期望值降低，从而达到无损压缩数据的目的。

例如，在英文中，e的出现机率最高，而z的出现概率则最低。当利用霍夫曼编码对一篇英文进行压缩时，e极有可能用一个比特来表示，而z则可能花去25个比特（不是26）。用普通的表示方法时，每个英文字母均占用一个字节，即8个比特。二者相比，e使用了一般编码的1/8的长度，z则使用了3倍多。倘若我们能实现对于英文中各个字母出现概率的较准确的估算，就可以大幅度提高无损压缩的比例。

霍夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的路径长度是从树根到每一结点的路径长度之和，记为WPL=（W1L1+W2L2+W3L3+…+WnLn），N个权值Wi（i=1,2,…n）构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li（i=1,2,…n）。可以证明霍夫曼树的WPL是最小的。

基本应用

1、哈夫曼编码

在数据通信中，需要将传送的文字转换成二进制的字符串，用0，1码的不同排列来表示字符。例如，需传送的报文为“AFTER DATA EAR ARE ART AREA”，这里用到的字符集为“A，E，R，T，F，D”，各字母出现的次数为{8，4，5，3，1，1}。现要求为这些字母设计编码。要区别6个字母，最简单的二进制编码方式是等长编码，固定采用3位二进制，可分别用000、001、010、011、100、101对“A，E，R，T，F，D”进行编码发送，当对方接收报文时再按照三位一分进行译码。显然编码的长度取决报文中不同字符的个数。若报文中可能出现26个不同字符，则固定编码长度为5。然而，传送报文时总是希望总长度尽可能短。在实际应用中，各个字符的出现频度或使用次数是不相同的，如A、B、C的使用频率远远高于X、Y、Z，自然会想到设计编码时，让使用频率高的用短码，使用频率低的用长码，以优化整个报文编码。

为使不等长编码为前缀编码(即要求一个字符的编码不能是另一个字符编码的前缀)，可用字符集中的每个字符作为叶子结点生成一棵编码二叉树，为了获得传送报文的最短长度，可将每个字符的出现频率作为字符结点的权值赋予该结点上，显然字使用频率越小权值越小，权值越小叶子就越靠下，于是频率小编码长，频率高编码短，这样就保证了此树的最小带权路径长度效果上就是传送报文的最短长度。因此，求传送报文的最短长度问题转化为求由字符集中的所有字符作为叶子结点，由字符出现频率作为其权值所产生的哈夫曼树的问题。利用哈夫曼树来设计二进制的前缀编码，既满足前缀编码的条件，又保证报文编码总长最短。

哈夫曼静态编码：它对需要编码的数据进行两遍扫描：第一遍统计原数据中各字符出现的频率，利用得到的频率值创建哈夫曼树，并必须把树的信息保存起来，即把字符0-255(28=256)的频率值以2-4BYTES的长度顺序存储起来，（用4Bytes的长度存储频率值，频率值的表示范围为0–232-1，这已足够表示大文件中字符出现的频率了）以便解压时创建同样的哈夫曼树进行解压；第二遍则根据第一遍扫描得到的哈夫曼树进行编码，并把编码后得到的码字存储起来。

哈夫曼动态编码：动态哈夫曼编码使用一棵动态变化的哈夫曼树，对第t+1个字符的编码是根据原始数据中前t个字符得到的哈夫曼树来进行的，编码和解码使用相同的初始哈夫曼树，每处理完一个字符，编码和解码使用相同的方法修改哈夫曼树，所以没有必要为解码而保存哈夫曼树的信息。编码和解码一个字符所需的时间与该字符的编码长度成正比，所以动态哈夫曼编码可实时进行。

2、哈夫曼译码

在通信中，若将字符用哈夫曼编码形式发送出去，对方接收到编码后，将编码还原成字符的过程，称为哈夫曼译码。

那么接下来直接步入正题上代码：

咳咳，拿着小板凳，学会Ctrl+c和Ctrl+v，这也是一种技巧

#include<stdio.h>
#include<malloc.h>
#include<string.h>

typedef struct HTNode
{
	char charname;
	 int weight;
	 int parent, lchild, rchild;
}HTNode, *HuffmanTree;


typedef char **HuffmanCode;    //动态分配数组存储字符编码的动态空间

int n=27,m=53;    // m=2*n-1   m为根节点个数
char *a;
int *b;

void HuffmanCoding(HuffmanTree HT,HuffmanCode HC,char *a,int *b,int n)
{
	int i;//通用整型变量i，用于循环中
	int s1 = 0;  //变量s1用于哈夫曼树的创建
	int s2 = 0;//变量s2用于哈夫曼树的创建
	int j;
	int d;
	int m=2 * n - 1;
	char *cd=(char*)malloc(n*sizeof(char));  //分配临时存放每个字符编码的动态空间，译码使用

//构造哈夫曼树HT
	if(n<=1)
	{
		return ;
	}//n值小于等于1，不满足创建哈弗曼树的条件
	//HT=(HuffmanTree)malloc(((2*n-1)+1)*sizeof(HTNode));
	for(i=1;i<=n;++i)
	{
		HT[i].charname=a[i-1];
		HT[i].weight=b[i-1];
		HT[i].parent=0;
		HT[i].lchild=-1;
		HT[i].rchild=-1; 	
	}
	for(;i<=m;++i)    //所要产生结点初始化所要产生结点
	{
		HT[i].charname='0';
		HT[i].weight=0;
		HT[i].parent=0;
		HT[i].lchild=-1;
		HT[i].rchild=-1;
	}


//以下功能为寻找权值字最小的两个值

	for(i=n+1;i<=m;++i)   //用于筛选出两个权重最小的两个
	{ 
		for(s1=1;HT[s1].parent!=0;)
		{
			s1++;
		}       //双亲不为0，让变量s1加1，寻找双亲为0的结点
 
		for (j=s1;j<=i-1;j++)    //用于寻找第一个双亲为0的结点
		{
			if(HT[j].parent!=0)
			{
				continue;
			}
			s1=HT[j].weight<HT[s1].weight?j:s1;  //寻找第一个权重最小的下标
		}
 
		HT[s1].parent=i;   
		HT[i].lchild=s1;
 
		for(s2=1;HT[s2].parent!=0;)   //同s1作用一样，找第二个双亲为0的结点
		{
			s2++;
		}
 
		for (j=s2;j<=i-1;j++)
		{
			if(HT[j].parent != 0)
			{
				continue;
			}
			s2 = HT[j].weight<HT[s2].weight?j:s2;
		}
		HT[s2].parent = i;
		HT[i].rchild = s2;
		HT[i].weight = HT[s1].weight+HT[s2].weight;  //将两个最小的结点权重相加组成父结点
	}


//求每个字符的哈夫曼编码，存储在编码HC中
//	HC=(HuffmanCode)malloc((n+1)*sizeof(char*));
	cd[n-1]='\0';  //存储编码值，下标n-1的为'\0'结束
	for (i=1; i<=n;++i)  //逐个字符求哈夫曼编码
	{
		int start=n-1,c,f;   //start开始时指向最后,既编码结束位置
		for (c=i,f=HT[i].parent; f!=0;c=f,f=HT[f].parent)  //f指向结点c的双亲结点，f！=0从叶子结点向上回溯，直到根结点
			                                               
		{
			if(HT[f].lchild==c)    //结点c是f的左孩子，则生成代码0
			{
				cd[--start]='0';    
			}
			else if(HT[f].rchild==c) //结点c是f的右孩子，则生成代码1
			{
				cd[--start]='1';
			}
		}
		HC[i]=(char*)malloc((n-start) * sizeof(char));//为每个字符分配空间
		f=n-start;   //继续回溯
		for(d=0;d<f;d++,start++)   //将cd数组中的字符译码值传送给HC的动态数组中去
		{
			HC[i][d]=cd[start];
		}
	}
	free(cd);   //释放临时空间
 
}

//信息存储函数
void cunchu_charnanme_Num()   
{
	int i;
	char charName[27]={' ','A','B','C','D','E','F','G','H','I','J','K','L','M','N',     //字符存储数组
				 'O','P','Q','R','S','T','U','V','W','X','Y','Z'} ;    
    int Weight[27]={'186','64','13','22','32','103','21','15','47','57','1','5','32','20','57',   //权重存储数组
					   '63','15','1','48','51','80','23','8','18','1','16','1'};
	
	a=(char *)malloc(n*sizeof(char));   //给全局变量a分配空间
	b=(int *)malloc(n*sizeof(int));     //给全局变量b分配空间

	for (i=0;i<n;i++)    //将数组charName内容给予数组a
	{
		a[i]=charName[i];
	}
  
	for(i=0;i<n;i++)   //将数组Weight内容给予数组b
	{
		b[i] = Weight[i];
	}
	
}

//显示哈夫曼树
void showHT_AND_showHC(HuffmanTree HT,HuffmanCode HC,int n, int m,char* a)
{
	int i=0;    
	int j=0;    
	int k=0;    //打印循环k

	printf("\n");
	printf("   >>>>所存储的哈夫曼编码以及译码<<<<\n");
	printf("  |__________________________________|\n");
	for (i = 1; i <= n; i++)      //已二维数组的形式输出哈夫曼树
	{
		printf("  |**%4c  :",a[i-1]);    //输出字符
		
		for(k=0;HC[i][k]!='\0'; k++)
		{
			printf("%c",HC[i][k]);   //输出字符对应的译码值
		
		}
	    printf("%13c",'*');
		printf("\n");
	}
	printf("  |__________________________________|\n");
	printf("\n");
}


//查找所需要的字母的编码值
void Find_letter(HuffmanTree HT,HuffmanCode HC,int n, int m,char* a)
{
	int i;
	int j;
	int k;
	int num=0;
	char find1[100];   //存字符码数组
	printf(">>>>>>>>>>>>>请输入所要查找的字符的编码值('#'结束输入):");
	for(i=0;;i++)                 //可循环输入字符，'#'结束输入
	{
		num++;
		scanf("%c",&find1[i]);
		if(find1[i]=='#')
		{
			 break;
		} 
		
	}

	printf("\n");
	printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>字符的哈夫曼编码是:");

	for (i=0;i<num;i++)                       //打印所找到对应字符的编码值
	{	
		for(k=1;k<n;k++)
		{	
			if(find1[i]==HT[k].charname)            //如果输入字符与存储数组字符相等，打印其编码
			{
				
				for(j=0;j<=11;j++)
				{	
			 		printf("%c",HC[k][j]);
				}
			}
		
		}
		//printf("\n");
	}
	printf("\n");
	printf("\n");
}


void Find_num(HuffmanTree HT,HuffmanCode HC,int n, int m,char* a)
{

	int i=0;
	int j;
	int k=0;
	int c=0;
	char find2[100];       //译码存放数组
	printf(">>>>>>>>>>>>请输入所需要查询译码对应字母的值('#'结束输入):");
	//scanf("%s",&find2);
    gets(find2);
	printf("\n");
	printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>所要查询的字符为:");

	while(find2[i]!='#')            //如果输入编码值结束不为'#'则进入while循环来找到对应的字符
	{
		for(j=1;j<28;j++)
		{	
			while(find2[i+k]==HC[j][k])         //如果找到输入译码值与存储译码值相等，进入
			{	
				//printf("0");
				k++;
				if(HC[j][k]=='\0')      //如译码数组结束'\0'
				{
				
					k--;
					printf("%c",HT[j].charname);   //打印对应的字符
					break;
				}
			
			}
		    if(find2[i+k]!=HC[j][k])    //不相等跳出循环，判断下一个二维数组值是否相等，直到找到为止
			{
				k=0;
				continue;
			} 
			else 
			{
				i=i+k+1;              //相等时让i=i+k+1,判断第二个字符编码值，如果没有则跳出
				k=0;
				continue;
			}
		}
	}
		printf("\n");
}
 
void main()
{
	int t;
	char ss;
	HuffmanTree HT;    
	HuffmanCode HC;
	HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));    //动态分配m+1个单元
	HC=(HuffmanCode)malloc(n*sizeof(HuffmanCode));   //动态分配n个单元

	cunchu_charnanme_Num();    //存储函数
	HuffmanCoding(HT, HC, a, b, n);   //存储译码函数



	while(t!=4)    //输入不同的值进行不同操作
	{	printf("     请输入相应字符开始执行程序\n");
		printf("\n");
		printf("     >>>>>1. 输出存储的哈夫曼编码和译码值 <<<<<\n");
		printf("     >>>>>2.输入字符获取其对应的二进制译码<<<<<\n");
		printf("     >>>>>3.  输入二进制获取其对应的字符  <<<<<\n");
	    printf("     >>>>>4.              退出            <<<<<\n");
		printf("          >>>>>>>>>>>>>>>输入<<<<<<<<<<<<<<<\n");
		printf("                     指令：  "); 
		scanf("%d",&t);
		switch(t)
		{
			 case 1:	
				
				 showHT_AND_showHC(HT, HC, n, m, a);   //输入1，打印存储哈夫曼
				 break;
			 case 2: 
				 Find_letter(HT, HC, n, m, a);   //输入2，寻找字符对应编码值
				 break;
			 case 3:
				 scanf("%c",&ss);
				 Find_num(HT, HC, n, m, a);   //输入3，寻找编码对应字符
				 break;
			 case 4: 
				 printf("          >>>>>>>>>>>>>>>退出<<<<<<<<<<<<<<<\n");   //输入4，退出系统
				 break;
				 
		}
	}
	
}

该注释懂得的地方我已经表明，相信大家一目了然！

附运行截图

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

一个简单的哈夫曼译码和编码就完成了，是不是简简单单、明明白白、一目了然，拜了个拜！

一九九八°
关注
  • 46
    点赞
  • 踩
  • 218
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
解析C++哈夫曼树编码和译码的实现
09-01
本篇文章主要介绍了C++哈夫曼树编码和译码的实现，详细的讲诉了哈夫曼树编码的原理，有需要的同学可以了解一下。
数据结构哈夫曼树编码译码实验报告--15页.pdf
09-05
在这个实验报告中，我们将实现一个哈夫曼树的编码译码系统，包括哈夫曼树的建立、编码、译码等功能。下面是哈夫曼树的详细设计和实现。 哈夫曼树的建立 哈夫曼树的建立可以通过两种方式：从键盘输入建立哈夫曼树和...
哈夫曼编码26个大写字符及空格、打印字符串的哈夫曼编码译文长度、哈夫曼编码反编译。
Jop_qq的博客
01-11 6617
     实现一个哈夫曼树的应用程序，可以按照以下每个字符的出现频率（权值）｛空格和26个英文字母出现频率分别为：186，64，13，22，32，103，21，15，47，57，1，5，32，20，57，63，15，1，48，51，80，23，8，18，1，16，1｝创建一棵哈夫曼树（要求左孩子的权值小于等于右孩子的权值）；并输出所有报文字符的编码，并将“THIS PROGRAM IS MY FA...
哈夫曼树的建立
最新发布
m0_73042050的博客
09-04 1840
哈夫曼树也叫最优二叉树，它可以用于数据压缩，实现编码和解码的过程。下文将描述哈夫曼树的构建方法以及其编码思想的应用。带权路径最短的二叉树。哈夫曼算法中，初始有n棵二叉树，经过n-1次合并最终形成哈夫曼树。经过n-1次合并产生n-1个新结点，且这n-1个新结点都是具有两个孩子的分支节点。可见：哈夫曼树中共有n+n-1=2n-1个结点，且起所有分支节点的度均不唯一度的定义是指该节点的子节点的个数。
统计文件中英文字母频率，并生成哈夫曼树（含编码和解码）
qq_55425006的博客
10-17 1501
统计文件中英文字母出现次数进行赋权值，根据字母权值生成最小哈夫曼树，并通过哈夫曼树进行编码，以及根据得到的编码本对二进制文件进行解码
第六周作业1——利用哈夫曼编码英文字母表
进击的自由人的专栏
04-16 700
哈夫曼编码
头歌数据结构构建哈夫曼树及编码
05-18
头歌数据结构构建哈夫曼树及编码 第1关构建哈夫曼树 第2关根据哈夫曼树构建哈夫曼编码 通过哈夫曼树的构造，深刻理解二叉树的构造。 通过哈夫曼编/译码过程，深刻领会二叉树的基本操作和二叉树的应用，熟练掌握...
哈夫曼编码/译码器数据结构课程设计
12-13
设计一个哈夫曼编码/译码系统，对一个文本文件中的字符进行哈夫曼编码，生成编码文件（后缀名.cod）；反过来，可将一个编码文件还原为一个文本文件(.txt)。 要求： （1）输入一个待编码的文本文件名，统计文本文件中...
哈夫曼编码译码器（数据结构）
12-09
总的来说，这个“哈夫曼编码译码器”提供了从构建哈夫曼树到实际编码解码的完整流程，对于学习和实践哈夫曼编码是一个很好的资源。同时，通过C++编程实现，也能锻炼到实际编程技能，对于计算机科学和技术的学习者来...
哈夫曼编码实验报告 数据结构
11-25
包括所有文档，调试成功！欢迎下载。哈夫曼编码实验报告，这是最新完成的。
哈夫曼树编码译码 数据结构
12-17
哈夫曼树编码译码 用下表给出的字符集和频度的实际统计数据建立哈夫曼树，并实现以下报文的编码和译码：“THIS PROGRAM IS MY FAVORITE” 字符 A B C D E F G H I J K L M 频度 64 13 22 32 103 21 15 47 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 1
实验报告及程序 哈夫曼树的编码和译码
06-13
这是本人在《数据结构》课上的 “ 哈夫曼树的编码和译码” 的实验报告及程序。建议手动敲一遍加深印象。
数据结构课程设计：哈夫曼编/译码的设计与实现（含文件）
08-09
一、问题描述 通过对简单哈夫曼编/译码系统的设计与实现来熟练掌握树型结构在实际问题中的...2、 用下表给出的字符集和频度的实际统计数据建立哈夫曼树，并实现以下报文的编码和译码：“THE PROGRAM IS MY FAVORITE”。
数据结构实验二哈夫曼树及哈夫曼编码译码的实现
06-07
哈夫曼树及哈夫曼编码译码的实现 哈夫曼树是一种特殊的二叉树，它的每个节点的权重是其所有子节点的权重之和。哈夫曼树的应用非常广泛，如数据压缩、编码、译码等。 哈夫曼树的存储结构 哈夫曼树的存储结构可以...
创建哈夫曼树并进行哈夫曼编码与哈夫曼译码
热门推荐
vivi_and_qiao的博客
09-22 1万+
图例 以上图例解释： 源代码下载链接： 哈夫曼树的创建，哈夫曼编码哈夫曼译码C语言实现代码 哈夫曼树的创建哈夫曼编码哈夫曼译码C语言实现代码markdown书写的html格式 如果需要将文件编码或译码，则应该加入文件操作，将文件的字符读入。其权重应该为在整个文件中该字符所出现的次数。
哈夫曼树的建立与编码及译码
11-07
数据结构实验，实现哈夫曼树的创建，并且实现编码和译码功能，满足任意字符串的输入，输出编码；也可满足任意编码输入，输出字符串。在创建哈夫曼树时输入权值与对应的字符。
哈夫曼树编码译码代码cpp
04-26
以下是哈夫曼树编码译码的C++代码示例： ```c++ #include <iostream> #include <string> #include <queue> #include <vector> #include <map> using namespace std; // 哈夫曼树节点 struct HuffmanNode { char ch; int freq; HuffmanNode *left, *right; HuffmanNode(char c, int f) { ch = c; freq = f; left = right = nullptr; } ~HuffmanNode() { delete left; delete right; } }; // 比较函数 struct Compare { bool operator()(const HuffmanNode* a, const HuffmanNode* b) const { return a->freq > b->freq; } }; // 构建哈夫曼树 HuffmanNode* buildHuffmanTree(map<char, int> freqMap) { priority_queue<HuffmanNode*, vector<HuffmanNode*>, Compare> pq; for (auto& p : freqMap) { pq.push(new HuffmanNode(p.first, p.second)); } while (pq.size() > 1) { HuffmanNode *left = pq.top(); pq.pop(); HuffmanNode *right = pq.top(); pq.pop(); HuffmanNode *parent = new HuffmanNode('$', left->freq + right->freq); parent->left = left; parent->right = right; pq.push(parent); } return pq.top(); } // 构建编码表 void buildCodeTable(HuffmanNode* root, string code, map<char, string>& codeTable) { if (root == nullptr) { return; } if (root->ch != '$') { codeTable[root->ch] = code; } buildCodeTable(root->left, code + "0", codeTable); buildCodeTable(root->right, code + "1", codeTable); } // 编码字符串 string encodeString(string str, map<char, string> codeTable) { string encodedString = ""; for (char c : str) { encodedString += codeTable[c]; } return encodedString; } // 译码字符串 string decodeString(string str, HuffmanNode* root) { string decodedString = ""; HuffmanNode* cur = root; for (char c : str) { if (c == '0') { cur = cur->left; } else { cur = cur->right; } if (cur->ch != '$') { decodedString += cur->ch; cur = root; } } return decodedString; } int main() { // 统计频率 string str = "hello, world!"; map<char, int> freqMap; for (char c : str) { freqMap[c]++; } // 构建哈夫曼树 HuffmanNode* root = buildHuffmanTree(freqMap); // 构建编码表 map<char, string> codeTable; buildCodeTable(root, "", codeTable); // 编码字符串 string encodedString = encodeString(str, codeTable); cout << "Encoded string: " << encodedString << endl; // 译码字符串 string decodedString = decodeString(encodedString, root); cout << "Decoded string: " << decodedString << endl; // 释放资源 delete root; return 0; } ``` 该程序的输入为一个字符串，输出为该字符串的哈夫曼编码和译码结果。程序首先统计输入字符串中每个字符出现的频率，并利用此信息构建哈夫曼树。然后，程序根据哈夫曼树构建编码表，用于将输入字符串编码为哈夫曼编码。最后，程序将哈夫曼编码译码为原始字符串。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值