哈夫曼编码原理

最新推荐文章于 2024-08-19 18:00:26 发布
最新推荐文章于 2024-08-19 18:00:26 发布
阅读量3.6k 收藏 11
点赞数 5
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a15608445683/article/details/125882298
版权

哈夫曼编码 前缀编码 二叉树 编码验证 最短路径
关键词由CSDN通过智能技术生成

一、应用背景

给定一段文字，如果我们统计出字母出现的频率，是可以根据哈夫曼算法给出一套编码，使得用此编码压缩原文可以得到最短的编码总长。然而哈夫曼编码并不是唯一的。例如对字符串"aaaxuaxz"，容易得到字母 'a'、'x'、'u'、'z' 的出现频率对应为 4、2、1、1。我们可以设计编码 {'a'=0, 'x'=10, 'u'=110, 'z'=111}，也可以用另一套 {'a'=1, 'x'=01, 'u'=001, 'z'=000}，还可以用 {'a'=0, 'x'=11, 'u'=100, 'z'=101}，三套编码都可以把原文压缩到 14 个字节。但是 {'a'=0, 'x'=01, 'u'=011, 'z'=001} 就不是哈夫曼编码，因为用这套编码压缩得到 00001011001001 后，解码的结果不唯一，"aaaxuaxz" 和 "aazuaxax" 都可以对应解码的结果。本题就请你判断任一套编码是否哈夫曼编码。

输入格式：

首先第一行给出一个正整数 N（2≤N≤63），随后第二行给出 N 个不重复的字符及其出现频率，格式如下：

c[1] f[1] c[2] f[2] ... c[N] f[N]

其中c[i]是集合{'0' - '9', 'a' - 'z', 'A' - 'Z', '_'}中的字符；f[i]是c[i]的出现频率，为不超过 1000 的整数。再下一行给出一个正整数 M（≤1000），随后是 M 套待检的编码。每套编码占 N 行，格式为：

c[i] code[i]

其中c[i]是第i个字符；code[i]是不超过63个'0'和'1'的非空字符串。

输出格式：

对每套待检编码，如果是正确的哈夫曼编码，就在一行中输出"Yes"，否则输出"No"。

注意：最优编码并不一定通过哈夫曼算法得到。任何能压缩到最优长度的前缀编码都应被判为正确。

输入样例：

7
A 1 B 1 C 1 D 3 E 3 F 6 G 6
4
A 00000
B 00001
C 0001
D 001
E 01
F 10
G 11
A 01010
B 01011
C 0100
D 011
E 10
F 11
G 00
A 000
B 001
C 010
D 011
E 100
F 101
G 110
A 00000
B 00001
C 0001
D 001
E 00
F 10
G 11

输出样例：

Yes
Yes
No
No

二、具体实现 

在完成这道题之前， 首先要对构建哈夫曼树和哈夫曼编码的框架有一定的理解。

之后再根据题目的要求进行恰当的修改。

以下代码参考   清华大学 《数据结构》（C语言版）严蔚敏 吴伟民 编著  

---------------------------------------数组从1开始，0未用。

框架代码如下： 

#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

#define MAXSIZE 100

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

typedef char** HuffmanCode;

void Init_HuffmanTree(HuffmanTree &HT,int n)
{
	int m = 2*n-1;
	HT = (HuffmanTree)malloc(sizeof(HTNode)*(m+1));
	for(int i=0;i<=m;i++)
	{
		HT[i].parent=0;
		HT[i].lchild=0;
		HT[i].rchild=0;
	}
}

void Select(HuffmanTree HT,int *S1,int *S2,int m)
{
	int minweight=10000;
	
	for(int i=1;i<m;i++)
	{
		if(HT[i].weight<minweight && HT[i].parent==0)
		{
			minweight = HT[i].weight;
			*S1 = i;
		}
	}
	
	minweight=10000;
	
	for(int i=1;i<m;i++)
	{
		if(HT[i].weight<minweight && HT[i].parent==0 && i!=*S1)
		{
			minweight = HT[i].weight;
			*S2 = i;
		}
	}
	
}

void Creat_HuffmanTree(HuffmanTree &HT,int n)
{
	int m = 2*n-1;
	int s1,s2;
	if(n<=1)
		return;
	
	for(int i=n+1;i<=m;i++)
	{
		Select(HT,&s1,&s2,i);
		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;
	}
}

void Print_HuffmanTree(HuffmanTree HT,int n)
{
	cout<<"index"<<"\t"<<"weight"<<"\t"<<"parent"<<"\t"<<"lchild"<<"\t"<<"rchild"<<endl;
	for(int i=1;i<=2*n-1;i++)
	{
		cout<<i<<"\t"<<HT[i].weight<<"\t"<<HT[i].parent<<"\t"<<HT[i].lchild<<"\t"<<HT[i].rchild<<endl;
	}
}

void Creat_HuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n)
{
	char *cd;
	int c,f,start;
	HC = (HuffmanCode)malloc(sizeof(char*)*(n+1));
	cd = (char*)malloc(sizeof(char)*n);
	cd[n-1]='\0';
	
	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';
			else cd[start]='1';
			
			c=f;
			f=HT[f].parent;
		}
		
		HC[i] = (char*)malloc(sizeof(char)*(n-start));
		strcpy(HC[i],&cd[start]);
	}
	free(cd);
}

void Print_HuffmanCode(char ch[][MAXSIZE],HuffmanCode HC,int n)
{
	for(int i=1;i<=n;i++)
	{
		cout<<ch[i]<<" ";
		cout<<HC[i]<<endl;
	}
}

int main()
{
	int n;
	char ch[MAXSIZE][MAXSIZE];
	HuffmanTree HT;
	HuffmanCode HC;
	
	
	cin>>n;
	Init_HuffmanTree(HT,n);
	
	for(int i=1;i<=n;i++)
	{
		cin>>ch[i]>>HT[i].weight;
	}
	
	
	Creat_HuffmanTree(HT,n);
	Creat_HuffmanCode(HT,HC,n);
	
	cout<<endl;
	Print_HuffmanTree(HT,n);
	cout<<endl;
	Print_HuffmanCode(ch,HC,n);
	cout<<endl; 
	return 0;
}

整体思路总结如下：

 构造最优二叉树（哈夫曼树），a、b、c、d、e的权值依次为7、5、5、2、4 。 程序运行结果如上图2。

 在有了相应的基础后，我们再来看这道题目。

仔细阅读题目过后我们发现，本题的初衷并不是让我们求出哈夫曼编码。题干说：“注意：最优编码并不一定通过哈夫曼算法得到。任何能压缩到最优长度的前缀编码都应被判为正确。”

这道题的解题思路为：先求出哈夫曼编码的的最短加权路径和然后再判断是不是前缀编码。两者缺一不可。

 完整代码如下：

#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

#define MAXSIZE 100

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

typedef char** HuffmanCode;

void Init_HuffmanTree(HuffmanTree &HT,int n)
{
	int m = 2*n-1;
	HT = (HuffmanTree)malloc(sizeof(HTNode)*(m+1));
	for(int i=0;i<=m;i++)
	{
		HT[i].parent=0;
		HT[i].lchild=0;
		HT[i].rchild=0;
	}
}

void Select(HuffmanTree HT,int *S1,int *S2,int m)
{
	int minweight=10000;
	
	for(int i=1;i<m;i++)
	{
		if(HT[i].weight<minweight && HT[i].parent==0)
		{
			minweight = HT[i].weight;
			*S1 = i;
		}
	}
	
	minweight=10000;
	
	for(int i=1;i<m;i++)
	{
		if(HT[i].weight<minweight && HT[i].parent==0 && i!=*S1)
		{
			minweight = HT[i].weight;
			*S2 = i;
		}
	}
	
}

void Creat_HuffmanTree(HuffmanTree &HT,int n)
{
	int m = 2*n-1;
	int s1,s2;
	if(n<=1)
		return;

//这里需要注意i是从n+1开始的	
	for(int i=n+1;i<=m;i++)
	{
		Select(HT,&s1,&s2,i);
		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;
	}
}

void Print_HuffmanTree(HuffmanTree HT,int n)
{
	cout<<"index"<<"\t"<<"weight"<<"\t"<<"parent"<<"\t"<<"lchild"<<"\t"<<"rchild"<<endl;
	for(int i=1;i<=2*n-1;i++)
	{
		cout<<i<<"\t"<<HT[i].weight<<"\t"<<HT[i].parent<<"\t"<<HT[i].lchild<<"\t"<<HT[i].rchild<<endl;
	}
}

int Creat_HuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n)
{
	char *cd;
	int c,f,start;
	HC = (HuffmanCode)malloc(sizeof(char*)*(n+1));
	cd = (char*)malloc(sizeof(char)*n);
	cd[n-1]='\0';
	
	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';
			else cd[start]='1';
			
			c=f;
			f=HT[f].parent;
		}
		
		HC[i] = (char*)malloc(sizeof(char)*(n-start));
		strcpy(HC[i],&cd[start]);
	}
	
	
	int sum=0;
	for(int i=n+1;i<2*n;i++)
	{
		sum+=HT[i].weight;
	}
	
	free(cd);
	return sum;
}

void Print_HuffmanCode(char ch[][MAXSIZE],HuffmanCode HC,int n)
{
	for(int i=1;i<=n;i++)
	{
		cout<<ch[i]<<" ";
		cout<<HC[i]<<endl;
	}
}

int IsPrefix(char code[MAXSIZE][MAXSIZE],int n)  //判断是否是前缀式编码 
{
	int flag=1; //1为是前缀式编码，0为否 
	for (int i = 1;i <= n;i++)
	{
		int j = i+1;
		while (j <= n && j!=i && flag == 1)
		{
			if (strstr(code[j-1], code[i-1]) != code[j-1]) //运用strstr函数 
			{
				if (j == n)
					j = 1;
				else j++;
			}
			else {
				flag = 0;
			}
		}

		if (flag == 0)
		{
			break;
		}
	}

	return flag;
}

int main()
{
	int n,sum_weight;
	char ch[MAXSIZE][MAXSIZE];
	HuffmanTree HT;
	HuffmanCode HC;

	cin>>n;
	Init_HuffmanTree(HT,n);
	
	for(int i=1;i<=n;i++)
	{
		cin>>ch[i]>>HT[i].weight;
	}
	
	
	Creat_HuffmanTree(HT,n);
	sum_weight = Creat_HuffmanCode(HT,HC,n);
	
	//Print_HuffmanTree(HT,n);
	//Print_HuffmanCode(ch,HC,n);
	
	//开始读入各段哈夫曼编码
	int M,sum=0;
	cin>>M;
	char code[MAXSIZE][MAXSIZE];
	char c;
	
	for(int i=1;i<=M;i++)
	{
		sum=0;
		for(int j=0;j<n;j++)
		{
			cin>>c>>code[j];
			sum+=strlen(code[j])*HT[j+1].weight; //求输入的加权路径：编码长度*权重 
		}
		if(sum!=sum_weight) //先判断最短加权路径和是否相等，若不等直接No,若相等，判断是否是前缀码 
		{
			cout<<"No"<<endl;
		}else{
			if(IsPrefix(code,n)==1)
				cout<<"Yes"<<endl;
			else cout<<"No"<<endl;
		}
	}
	return 0;
}

下面我们来看这个代码，注意与第一个框架代码做对比。

  • 首先在 Creat_HuffmanCode（） 函数中，我们加入如下代码1，来求最短加权路径和。用于与主函数中（代码2）输入的哈夫曼编码作比较。
  • 依照上面的图1，找到相应的数学关系。
//代码1
int sum=0;
	for(int i=n+1;i<2*n;i++)  //注意从n+1开始
	{
		sum+=HT[i].weight;
	}

return sum;
//代码2
sum=0;
		for(int j=0;j<n;j++)
		{
			cin>>c>>code[j];
			sum+=strlen(code[j])*HT[j+1].weight; //求输入的加权路径：编码长度*权重 
		}
  • 写了 IsPrefix（） 函数用于判断是否是前缀码。相应代码的思路如下：

前缀编码定义：
（字符集中）任一编码都不是其它字符的编码的前缀


例：
(1)找出下面不是前缀编码的选项
A{1，01，000，001}
B{1，01，011，010}
C{0，10，110，11}
D{0，1，00，11}

第一步：看A中的第一个数1，看看其他数有没有1开头的。没有。
第二步：看A中的第二个数01，看看其他数有没有01开头的。没有。
第三步：看看A中的第三个数000，看看其他数有没有000开头的。没有。
第四步：看看A中的第四个数001，看看其他数有没有001开头的。没有。
所以A是前缀编码。

其他选项也一样。B、C也一样。来说说D：

第一步，看D中的第一个数，找有0开头的的数，有，是00；其实到这里已经不用看了
因为D已经不是前缀编码了。
但第二个数1，是第四个数11的前缀，所以也能作为D不是前缀编码的理由。

  IsPrefix（） 函数中应用了strstr()函数。解释如下：

最后，题干的测试数据：

4
a 4
x 2
u 1
z 1
4
a 0
x 10
u 110
z 111
a 1
x 01
u 001
z 000
a 0
x 11
u 100
z 101
a 0
x 01
u 011
z 001

追光少年羽
关注
专栏目录
huffman编码的程序流程图_哈夫曼编码原理详解及应用实例,哈夫曼编码算法流程图 - 全文...
weixin_39908758的博客
12-20 6139
摘要：作为一种常用的编码方式即哈夫曼编码，很多人在它的原理即应用方面都弄不不清楚，本文主要以哈夫曼编码原理与应用实例及算法流程图俩进一步说明。哈夫曼编码定义哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一...
哈夫曼编码详细讲解 原理实现
12-28
哈夫曼编码详细讲解 原理实现 让你从零开始轻松学会
哈夫曼编码（小顶堆）
最新发布
qq_74143684的博客
08-19 743
哈夫曼编码是一种根据字符出现频率设计的变长编码方式，常用于数据压缩。它的基本思想是，将出现频率较高的字符用较短的编码表示，而出现频率较低的字符用较长的编码表示，从而减小编码的总长度。
哈夫曼编码（Huffman Coding）原理详解
lxh_xgz的博客
11-02 2650
哈夫曼编码，又称为哈夫曼编码（Huffman Coding）是一种可变长编码（ VLC, variable length coding)）方式，比起定长编码的 ASCII 编码来说，哈夫曼编码能节省很多的空间，因为每一个字符出现的频率不是一致的；是一种用于无损数据压缩的熵编码算法，通常用于压缩重复率比较高的字符数据。
哈夫曼编码的原理与实现
超纯的小白兔
09-29 2100
我们设置一个结构数组 HuffNode 保存哈夫曼树中各结点的信息。根据二叉树的性质可知，具有n个叶子结点的哈夫曼树共有 2n-1 个结点，所以数组 HuffNode 的大小设置为 2n-1 。HuffNode 结构中有 weight, lchild, rchild 和 parent 域。其中，weight 域保存结点的权值, lchild 和 rchild 分别保存该结点的左、右孩子的结点在数组
哈夫曼编码原理以及实现
热门推荐
u014276600的博客
11-26 2万+
哈夫曼编码原理以及实现
哈夫曼编码原理及实现代码
程序媛的自学笔记
02-27 8053
1）初始化：根据给定的n个权值 ，构造n棵只有一个根结点的二叉树， n个权值分别是这些二叉树根结点的权。 2）找最小树：在F中选取两棵根结点树值最小的树作为左、右子树，构造一颗新的二叉树，置新二叉树根的权值为左、右子树根结点权值之和； 3）删除与加入：从F中删除这两颗树，并将新树加入F； 判断：重复 2) 和3)，直到F中只含一颗树为止，此时得到的这颗二叉树就是哈夫曼树。 ...
Matlab进行图像霍夫曼编码
07-11
以下我们将详细探讨霍夫曼编码的原理及其在MATLAB中的实现。 首先，霍夫曼编码的核心思想是根据字符出现的频率来分配不同的二进制码字。频率较高的字符将获得较短的码字，反之频率较低的字符则对应较长的码字。这样...
用哈夫曼编码统计一段英文中字母的频率
03-03
输入任意一段英文，自动统计其中各字母出现的频率及次数，并在屏幕上输出结果
哈夫曼编码压缩文本从一个文本文件中读入文本，统计一共出现了多少个字符以及每个字符出现的次数，用前缀码对不同字符进行表示，并对文本进行压缩，最后计算出压缩率。
12-17
文本: a b c a c a d b a c d a b a a c b a b a 传统表示方法：a: 00, b: 01, c: 10, d: 11 传统表示未压缩时： 0001100010001101001011001000001001001000 统计次数：a:9, b:5, c:4, d:2 前缀码表示：a: 0, b: 10, c:110, d:111 压缩后： 0101100110011110011011101000110100100
统计英文文本每个字母出现概率（不分大小写）并进行哈夫曼，香农编码
01-12
只统计英文文本的26个字母（不分大小写）出现概率，并对这26个字母进行哈夫曼编码，香农编码，主程序在CalculateLetters_Number.m中。
数据压缩之经典——哈夫曼编码(Huffman)
weixin_34062469的博客
05-02 948
(笔记图片截图自课程Image and video processing: From Mars to Hollywood with a stop at the hospital的教学视频，使用时请注意版权要求。) JPEG用哈夫曼编码(Huffman Encoder)作为其符号编码。哈弗曼编码是压缩算法中的经典，它理论上可以将数据编成平均长度最小的无前缀码(Prefix-Free Code)。 ...
哈夫曼编码原理代码
code_mzh的博客
07-12 455
哈夫曼树─即最优二叉树，带权路径长度最小的二叉树，经常应用于数据压缩。通过将高频率字符用较短字节进行表示而不是统一表示的方法达到字符串的压缩。 啥是带权路径？- 每一个结点代表着不同的数字，而这些不同的数字称作结点的权值。 二叉树中一个结点到另一个结点经过的结点方式是唯一的，这些经过的结点称作两个结点之间的路径。而由结点A到结点B中间经历的结点数目加1即为结点A到B的路径长度。 哈夫曼为啥是前缀编码？ 因为**定长编码已经用相同的位数这个条件保证了任一个字符的编码都不会成为其它编码的前缀,**所以这种情
Huffman编码原理及实现
u010029439的博客
02-01 1100
Lipracer关注 2018.10.18 23:03:00字数 251阅读 1,116 Huffman编码特点： 熵编码，编码效率受限信息理论熵极限（关于这部分具体理论记不得，参考物理的熵，熵极大，就是最混乱的状态，最混乱莫过于在一定码长的情况下尽可能表现多的信息，这个码长就是最短码长，也就是熵编码的理论极限，算术编码最接近理论极限，实现起来难度较大）以上均为无损压缩理论，有损压缩不...
哈夫曼编码原理及实现
qq_35803412的博客
09-17 3281
构建编码树的方法是将频率最低的两个符号合并为一个新节点，该节点的频率为两个节点频率之和。哈夫曼编码（Huffman Coding）是一种用于数据压缩的编码方法，它通过给出不同的数据符号分配不同长度的编码，使得出现频率高的符号具有较短的编码，而出现频率低的符号具有较长的编码，从而达到压缩数据的目的。然而，对于哈夫曼编码的最佳性能，符号的频率应该是根据数据集的统计特征进行调整的。由于频率高的符号具有较短的编码，而频率低的符号具有较长的编码，所以整个编码后的数据长度会相对减小。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值