哈夫曼树建树编码解码

已于 2023-12-06 16:25:32 修改
阅读量1k 收藏 6
点赞数 1
分类专栏： 数据结构 文章标签： 霍夫曼树 算法 数据结构
于 2022-05-10 00:34:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56012214/article/details/124658708
版权

提示：昼短苦夜长，何不秉烛游！

文章目录

再此声明因为构造过程中会有重复值的出现 导致构造的树 并不一定一样 也就导致解码 编码的不同

一、哈夫曼解析

1、手写哈夫曼树

在学这个之前 首先来借用使用一个图来帮助我们来理解 先来教大家怎么构建这样一个树，首先给定一系列数字， 从中选取两个最小的值来构成左右子树， 假如现在给定的就是 1 2 3 4 5 四个节点 从中选择 最小的两个值 但是两个值中小的一个作为 左子树，大的值一个作为右子树 (这个大的作为右子树 也是默认的，其实没有规定 若是你想 大的作为左子树也是可以的 但是要统一)此时你应该也可以看出 其中最小的两个值就是1和2，，选择1 2 来构成一棵树，那么根结点应该是谁呢 这里是使用两者和作为根 也就构成如图所示

请添加图片描述
然后将合并后的值3作为新结点放入序列中，删除序列中已经使用过的值 此时也就是 3 3 4 5 此时再选择两个小的
但是此时最小的两个的值是一样的 都是三 此时谁应该放在左边呢？ 这里都可以 计算出来树的带权路径长度是一样的， 所以 通过这个可以使用序列尽管相同 但是构成的树 却不一定是 一样的 我认为 若是序列在初始 或者处理的过程中 若是有重复的值 也就会造成 树的不同 但是构成的树的最短带权路径长度依然是一样的
也就构成下图

请添加图片描述

重复上以上步骤继续选择两个构成 添加新合并的值 作为新结点放入序列中，然后删两个 较小的值 此时是6 4 5
再从中选取两个最小值

请添加图片描述

再填加一个值，再删两个值 6 9 此时序列中也就两个值 树成！！！

请添加图片描述

2、为什么这样构成哈夫曼树？

在解决这个问题之前，我们需要知道什么是几个概念，路径长度 带权路径长度

路径

从一个结点往下可以到达的结点之间的通路 称为路径

路径长度：

某一个路径所经过的边的数量 称为该路径的路径长度 等于经过的结点数减一

带权路径长度

将树中结点赋值给一个带有某种含义的数值，则该数值称为该结点的权 从根节点到该结点之间的路径长度与该结点的权的乘积 称为该结点的带权路径长度

树的最带权路径长度

树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL。

哈夫曼树

给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，则称该二叉树为哈夫曼树，也被称为最优二叉树 但是如何才能使得带权路径最小 根据计算方式 我们想到我们应该尽可能地让权值大的叶子结点靠近根结点，让权值小的叶子结点远离根结点，这样便能使得这棵二叉树的带权路径长度达到最小

二、构建哈夫曼树

使用之前的三叉动态链表的方式也是可以实现的 ，但是这里具体较之前的优点在哪 ，一个可能的原因是方便随机存取吧，

//哈夫曼树结点结构
typedef struct HTNode 
{
	char data; //数据,非叶节点为NULL
	double weight;//权重
	int parent;//双亲，-1表示没有双亲，即根节点
	int lchild;//左孩子，数组下标,-1表示无左孩子，即叶节点
	int rchild;//右孩子
}HTnode;

简单来说 其实也就是一个填表的过程 ，将下表填充完整
请添加图片描述
数组上方五个存放的是叶子结点下面四个存放的是非叶子节点， 其中lchild 和rchild 存储的都是数组的下标 ，也就是从0以开始的，根结点是没有父亲结点 我们使用一个-1标志，同理若是为叶子节点其中孩子结点为-1

#include<bits/stdc++.h>
#define ElemType int
#define Max 100;
using namespace std;
typedef struct HTNode{
	char data;
	double weight;
	int parent=-1;
	int lchild=-1;
	int rchild=-1;
}HTNode;
int n;
HTNode HTree[100];
void Creat(){//创建一个哈夫曼树
	cout<<"请输入你要填入字符的个数"<<endl;vector<int> Vec; 
	cin>>n;
	cout<<"请输入字符以及对应的权值"<<endl;
	for(int i=0;i<n;i++){
		cin>>HTree[i].data>>HTree[i].weight; 
		Vec.push_back(HTree[i].weight);
	}
	//上面几句完成了初始化  接下来进行造树(填表)
		for(int i=n;i<2*n-1;i++){ //将HTree数组中的剩下的填充完即可结束 
			if(Vec.size()==1) break;
			sort(Vec.begin(),Vec.end());
			//遍历来寻找最小值以及次小值在HTree中的坐标  但是要注意此时是给这两个结点找父亲 所以他们不能已经有了父亲 
			for(int j=0;j<i;j++){
				if(Vec[0]==HTree[j].weight&&HTree[j].parent==-1){//找最小值的父亲 
					HTree[j].parent=i;
					HTree[i].lchild=j;	
					break;//是为了避免重复值的问题 
				}
			} 
			for(int j=0;j<i;j++){
				if(Vec[1]==HTree[j].weight&&HTree[j].parent==-1){
					HTree[j].parent=i;
					HTree[i].rchild=j;
					break;
				}
			} 
			HTree[i].weight=Vec[0]+Vec[1];
			//成功一次之后 需要删除两个 添加一个
			Vec.erase(Vec.begin(),Vec.begin()+2);
			Vec.push_back(HTree[i].weight); 
		}  
}
void PrintHT()
{
	cout << "下标\t" << "数据\t" << "权重\t" << "双亲\t" << "左孩子\t" << "右孩子" << endl;
	for (int i = 0; i<n*2-1; i++)
	{
		cout << i << "\t" << HTree[i].data << "\t" << HTree[i].weight 
		<< "\t" << HTree[i].parent << "\t" << HTree[i].lchild << "\t" << HTree[i].rchild << endl;
	}
}
int main(){
	Creat();
	PrintHT();
	return 0;	
}

请添加图片描述

三、哈夫曼树编码

从根结点到叶子结点 往左是零 往右是一
这里不知道大家想到之前写过的一个题目 二叉树的所有路径 其中就是寻找根结点到所有叶子结点的路径，虽然这道题我们不使用所有路径的方法哈哈哈 因为每一个结点都有父亲并且叶子结点就在数组的前n个 找到之后反转一下即可 并且我们需要绑定每一个字符对应的哈夫曼编码 所以也就是需要定义一个结构体

typedef struct HFNode{
	char data;
	string str;
}HFNode;

整体代码如下

#include<bits/stdc++.h>
#define ElemType int
#define Max 100;
using namespace std;
typedef struct HTNode{
	char data;
	double weight;
	int parent=-1;
	int lchild=-1;
	int rchild=-1;
}HTNode;
typedef struct HFNode{
	char data;
	string str;
}HFNode;
int n;
HTNode HTree[100];
HFNode HFCode[100]; 
void Creat(){//创建一个哈夫曼树
	cout<<"请输入你要填入字符的个数"<<endl;vector<int> Vec; 
	cin>>n;
	cout<<"请输入字符以及对应的权值"<<endl;
	for(int i=0;i<n;i++){
		cin>>HTree[i].data>>HTree[i].weight; 
		HFCode[i].data=HTree[i].data;
		Vec.push_back(HTree[i].weight);
	}
	//上面几句完成了初始化  接下来进行造树(填表)
		for(int i=n;i<2*n-1;i++){ //将HTree数组中的剩下的填充完即可结束 
			if(Vec.size()==1) break;
			sort(Vec.begin(),Vec.end());
			//遍历来寻找最小值以及次小值在HTree中的坐标  但是要注意此时是给这两个结点找父亲 所以他们不能已经有了父亲 
			for(int j=0;j<i;j++){
				if(Vec[0]==HTree[j].weight&&HTree[j].parent==-1){//找最小值的父亲 
					HTree[j].parent=i;
					HTree[i].lchild=j;	
					break;//是为了避免重复值的问题 
				}
			} 
			for(int j=0;j<i;j++){
				if(Vec[1]==HTree[j].weight&&HTree[j].parent==-1){
					HTree[j].parent=i;
					HTree[i].rchild=j;
					break;
				}
			} 
			HTree[i].weight=Vec[0]+Vec[1];
			//成功一次之后 需要删除两个 添加一个
			Vec.erase(Vec.begin(),Vec.begin()+2);
			Vec.push_back(HTree[i].weight); 
		}  
}
void DealHFCodeString(){
	for(int i=0;i<n;i++){//对n个结点进行string的赋值 
		int Cur=i;//指向此时的第一个叶子节点 
		string Str;
		while(HTree[Cur].parent!=-1){
			if(HTree[HTree[Cur].parent].lchild==Cur){
				Str+=to_string(0);
			}
			else{
				Str+=to_string(1);
			}
			Cur=HTree[Cur].parent;
		} 
		reverse(Str.begin(),Str.end());
		HFCode[i].str=Str;
	}
}
//打印哈夫曼树
void PrintHT()
{
	cout << "下标\t" << "数据\t" << "权重\t" << "双亲\t" << "左孩子\t" << "右孩子" << endl;
	for (int i = 0; i<n*2-1; i++)
	{
		cout << i << "\t" << HTree[i].data << "\t" << HTree[i].weight << "\t" 
		<< HTree[i].parent << "\t" << HTree[i].lchild << "\t" << HTree[i].rchild << endl;
	}
}
void PrintHFC(){
	cout<<"数据\t"<<"哈夫曼编码\t"<<endl;
	for(int i=0;i<n;i++){
		cout<<HTree[i].data<<"\t"<<HFCode[i].str<<"\t"<<endl;
	} 
}
int main(){
	Creat();
	PrintHT();
	DealHFCodeString();
	PrintHFC();
	return 0;	
}

四、哈夫曼解码

简单的来说 就是给定一个01构成的字符串根据这个字符串相对应的字符，不过这里要考虑不止一个字符的情况，这里使用一个字符串来放解码的结果，若是能到叶子结点则将此时到达的叶子结点放入结果集中，然后从头继续匹配，还有就是是否会输入不正确的时候 什么时候会输入不正确呢？ 输入字符串的最后一段在从根结点匹配的过程中到达不了叶子结点 即为输入不正确 若是Cur停留的是在根结点 就说明输入没有问题
下面写出代码

//哈夫曼解码
string HFDecode(){
	string Str;string result;
	cout<<"请输入一段01 构成的字符串"<<endl;
	cin>>Str; int Cur=n*2-2;
	//我们知道树根是放在数组的最后一个的位置上
	while(!Str.empty()){//字符串中为空的时候 也是要退出的 
		if(Str.front()=='1'){//向右深入
			cout<<"向右深入"<<endl; 
			Cur=HTree[Cur].rchild;
			Str.erase(Str.begin(),Str.begin()+1);
		}
		else{//向左深入 
			cout<<"向左深入"<<endl; 
			Cur=HTree[Cur].lchild;
			Str.erase(Str.begin(),Str.begin()+1);
		} 
		if(HTree[Cur].lchild==-1){//说明此时是叶子结点 将此时对应的结果放在result中 
			cout<<"将"<<HTree[Cur].data<<"放入结果集合中"<<endl; 
			result+=HTree[Cur].data;
			Cur=n*2-2;//到达叶子节点重新指向根结点 
		}
	} 
	if(HTree[Cur].parent!=-1){//遍历完成的时候若是Cur指向的不是叶子结点 输入有问题
		cout<<"此时你输入的有问题"<<endl;
		result.erase(result.begin(),result.end());
		return result;
	}
	return result;
}

请添加图片描述

解码需要根据编码来看，若是多加一个数子 则输入错误
请添加图片描述

可运行如下

#include<bits/stdc++.h>
#define ElemType int
#define Max 100;
using namespace std;
typedef struct HTNode{
	char data;
	double weight;
	int parent=-1;
	int lchild=-1;
	int rchild=-1;
}HTNode;
typedef struct HFNode{
	char data;
	string str;
}HFNode;
int n;
HTNode HTree[100];
HFNode HFCode[100]; 
void Creat(){//创建一个哈夫曼树
	cout<<"请输入你要填入字符的个数"<<endl;vector<int> Vec; 
	cin>>n;
	cout<<"请输入字符以及对应的权值"<<endl;
	for(int i=0;i<n;i++){
		cin>>HTree[i].data>>HTree[i].weight; 
		HFCode[i].data=HTree[i].data;
		Vec.push_back(HTree[i].weight);
	}
	//上面几句完成了初始化  接下来进行造树(填表)
		for(int i=n;i<2*n-1;i++){ //将HTree数组中的剩下的填充完即可结束 
			if(Vec.size()==1) break;
			sort(Vec.begin(),Vec.end());
			//遍历来寻找最小值以及次小值在HTree中的坐标  但是要注意此时是给这两个结点找父亲 所以他们不能已经有了父亲 
			for(int j=0;j<i;j++){
				if(Vec[0]==HTree[j].weight&&HTree[j].parent==-1){//找最小值的父亲 
					HTree[j].parent=i;
					HTree[i].lchild=j;	
					break;//是为了避免重复值的问题 
				}
			} 
			for(int j=0;j<i;j++){
				if(Vec[1]==HTree[j].weight&&HTree[j].parent==-1){
					HTree[j].parent=i;
					HTree[i].rchild=j;
					break;
				}
			} 
			HTree[i].weight=Vec[0]+Vec[1];
			//成功一次之后 需要删除两个 添加一个
			Vec.erase(Vec.begin(),Vec.begin()+2);
			Vec.push_back(HTree[i].weight); 
		}  
}
//哈夫曼编码 
void DealHFCodeString(){
	for(int i=0;i<n;i++){//对n个结点进行string的赋值 
		int Cur=i;//指向此时的第一个叶子节点 
		string Str;
		while(HTree[Cur].parent!=-1){
			if(HTree[HTree[Cur].parent].lchild==Cur){
				Str+=to_string(0);
			}
			else{
				Str+=to_string(1);
			}
			Cur=HTree[Cur].parent;
		} 
		reverse(Str.begin(),Str.end());
		HFCode[i].str=Str;
	}
}
//哈夫曼解码
string HFDecode(){
	string Str;string result;
	cout<<"请输入一段01 构成的字符串"<<endl;
	cin>>Str; int Cur=n*2-2;
	//我们知道树根是放在数组的最后一个的位置上
	while(!Str.empty()){//字符串中为空的时候 也是要退出的 
		if(Str.front()=='1'){//向右深入
			cout<<"向右深入"<<endl; 
			Cur=HTree[Cur].rchild;
			Str.erase(Str.begin(),Str.begin()+1);
		}
		else{//向左深入 
			cout<<"向左深入"<<endl; 
			Cur=HTree[Cur].lchild;
			Str.erase(Str.begin(),Str.begin()+1);
		} 
		if(HTree[Cur].lchild==-1){//说明此时是叶子结点 将此时对应的结果放在result中 
			cout<<"将"<<HTree[Cur].data<<"放入结果集合中"<<endl; 
			result+=HTree[Cur].data;
			Cur=n*2-2;//到达叶子节点重新指向根结点 
		}
	} 
	if(HTree[Cur].parent!=-1){//遍历完成的时候若是Cur指向的不是叶子结点 输入有问题
		cout<<"此时你输入的有问题"<<endl;
		result.erase(result.begin(),result.end());
		return result;
	}
	return result;
} 
//打印哈夫曼树
void PrintHT()
{
	cout << "下标\t" << "数据\t" << "权重\t" << "双亲\t" << "左孩子\t" << "右孩子" << endl;
	for (int i = 0; i<n*2-1; i++)
	{
		cout << i << "\t" << HTree[i].data << "\t" << HTree[i].weight << "\t" 
		<< HTree[i].parent << "\t" << HTree[i].lchild << "\t" << HTree[i].rchild << endl;
	}
}
void PrintHFC(){
	cout<<"数据\t"<<"哈夫曼编码\t"<<endl;
	for(int i=0;i<n;i++){
		cout<<HTree[i].data<<"\t"<<HFCode[i].str<<"\t"<<endl;
	} 
}
int main(){
	Creat();
	PrintHT();
	DealHFCodeString();
	PrintHFC();
	cout<<"此时的解码之后的是"<<HFDecode()<<endl;; 
	while(1){
		cout<<"是否继续解码 是的话 请输入1  否则请输入0"<<endl;
		int flag; cin>>flag;
		if(1==flag){
			cout<<"此时的解码之后的是"<<HFDecode()<<endl;
		}
		else{
			break;
		}
	}
	return 0;	
}

五、求树的权值

其实思想倒是简单 也就是所以叶子结点路径长度乘上权重 叶子结点好找 也就是数组前n个就是叶子结点 路径长度叶子结点往上找到根结点就可以了，下面写出代码

//计算树的权重  
int HFWeight(){
	int sum=0;
	for(int i=0;i<n;i++){//遍历前n个叶子结点求所有叶子结点带权路径长度的和
		int Cur=i;int Deep=0;
		while(HTree[Cur].parent!=-1){ 
			Deep++;
			Cur=HTree[Cur].parent;
		} 
		sum+=HTree[i].weight*Deep;
	} 
	return sum; 
}

请添加图片描述

六、整体代码

#include<bits/stdc++.h>
#define ElemType int
#define Max 100;
using namespace std;
typedef struct HTNode{
	char data;
	double weight;
	int parent=-1;
	int lchild=-1;
	int rchild=-1;
}HTNode;
typedef struct HFNode{
	char data;
	string str;
}HFNode;
int n;
HTNode HTree[100];
HFNode HFCode[100]; 
void Creat(){//创建一个哈夫曼树
	cout<<"请输入你要填入字符的个数"<<endl;vector<int> Vec; 
	cin>>n;
	cout<<"请输入字符以及对应的权值"<<endl;
	for(int i=0;i<n;i++){
		cin>>HTree[i].data>>HTree[i].weight; 
		HFCode[i].data=HTree[i].data;
		Vec.push_back(HTree[i].weight);
	}
	//上面几句完成了初始化  接下来进行造树(填表)
		for(int i=n;i<2*n-1;i++){ //将HTree数组中的剩下的填充完即可结束 
			if(Vec.size()==1) break;
			sort(Vec.begin(),Vec.end());
			//遍历来寻找最小值以及次小值在HTree中的坐标  但是要注意此时是给这两个结点找父亲 所以他们不能已经有了父亲 
			for(int j=0;j<i;j++){
				if(Vec[0]==HTree[j].weight&&HTree[j].parent==-1){//找最小值的父亲 
					HTree[j].parent=i;
					HTree[i].lchild=j;	
					break;//是为了避免重复值的问题 
				}
			} 
			for(int j=0;j<i;j++){
				if(Vec[1]==HTree[j].weight&&HTree[j].parent==-1){
					HTree[j].parent=i;
					HTree[i].rchild=j;
					break;
				}
			} 
			HTree[i].weight=Vec[0]+Vec[1];
			//成功一次之后 需要删除两个 添加一个
			Vec.erase(Vec.begin(),Vec.begin()+2);
			Vec.push_back(HTree[i].weight); 
		}  
}
//哈夫曼编码 
void DealHFCodeString(){
	for(int i=0;i<n;i++){//对n个结点进行string的赋值 
		int Cur=i;//指向此时的第一个叶子节点 
		string Str;
		while(HTree[Cur].parent!=-1){
			if(HTree[HTree[Cur].parent].lchild==Cur){
				Str+=to_string(0);
			}
			else{
				Str+=to_string(1);
			}
			Cur=HTree[Cur].parent;
		} 
		reverse(Str.begin(),Str.end());
		HFCode[i].str=Str;
	}
}
//哈夫曼解码
string HFDecode(){
	string Str;string result;
	cout<<"请输入一段01 构成的字符串"<<endl;
	cin>>Str; int Cur=n*2-2;
	//我们知道树根是放在数组的最后一个的位置上
	while(!Str.empty()){//字符串中为空的时候 也是要退出的 
		if(Str.front()=='1'){//向右深入
			cout<<"向右深入"<<endl; 
			Cur=HTree[Cur].rchild;
			Str.erase(Str.begin(),Str.begin()+1);
		}
		else{//向左深入 
			cout<<"向左深入"<<endl; 
			Cur=HTree[Cur].lchild;
			Str.erase(Str.begin(),Str.begin()+1);
		} 
		if(HTree[Cur].lchild==-1){//说明此时是叶子结点 将此时对应的结果放在result中 
			cout<<"将"<<HTree[Cur].data<<"放入结果集合中"<<endl; 
			result+=HTree[Cur].data;
			Cur=n*2-2;//到达叶子节点重新指向根结点 
		}
	} 
	if(HTree[Cur].parent!=-1){//遍历完成的时候若是Cur指向的不是叶子结点 输入有问题
		cout<<"此时你输入的有问题"<<endl;
		result.erase(result.begin(),result.end());
		return result;
	}
	return result;
} 
//打印哈夫曼树
void PrintHT()
{
	cout << "下标\t" << "数据\t" << "权重\t" << "双亲\t" << "左孩子\t" << "右孩子" << endl;
	for (int i = 0; i<n*2-1; i++)
	{
		cout << i << "\t" << HTree[i].data << "\t" << HTree[i].weight << "\t" 
		<< HTree[i].parent << "\t" << HTree[i].lchild << "\t" << HTree[i].rchild << endl;
	}
}
//打印字母对应的哈夫曼编码 
void PrintHFC(){
	cout<<"数据\t"<<"哈夫曼编码\t"<<endl;
	for(int i=0;i<n;i++){
		cout<<HTree[i].data<<"\t"<<HFCode[i].str<<"\t"<<endl;
	} 
}
//计算树的权重  
int HFWeight(){
	int sum=0;
	for(int i=0;i<n;i++){//遍历前n个叶子结点求所有叶子结点带权路径长度的和
		int Cur=i;int Deep=0;
		while(HTree[Cur].parent!=-1){ 
			Deep++;
			Cur=HTree[Cur].parent;
		} 
		sum+=HTree[i].weight*Deep;
	} 
	return sum; 
}
int main(){
	Creat();
	PrintHT();
	DealHFCodeString();
	PrintHFC();
	cout<<"此时树的权重是"<<HFWeight()<<endl; 
	cout<<"此时的解码之后的是"<<HFDecode()<<endl;
	while(1){
		cout<<"是否继续解码 是的话 请输入1  否则请输入0"<<endl;
		int flag; cin>>flag;
		if(1==flag){
			cout<<"此时的解码之后的是"<<HFDecode()<<endl;
		}
		else{
			break;
		}
	}
	return 0;	
}

总结

有些时候是需要自己来写一下的 建议读者尝试一下 理解了其实也不难 大家加油！感觉不错点个赞呗

Dream of maid
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈夫曼树的编码与解码
AKGWSB 's blog
12-21 7815
DS二叉树——Huffman编码与解码 哈夫曼树简介 给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 根据数据出现的频率，使用不同长度的编码 一段文字由x个字符组成，每个字符的出现频率不同，比如a出现114514次，而c只出现了810次，如果对a使用短长度的...
Huffman编码与解码
的博客
03-18 1万+
使用C++、和Java分别实现构造哈夫曼树
哈夫曼树及哈夫曼树的编码解码
ZERO_IT_C的博客
05-11 2757
总节点n = x + y = 边数 + 1 = my + 1 -> x = (x - 1) / (m - 1) -> n = x + y = (m*x - 1) / (m - 1)总节点数n = (m*x - 1) / (m - 1) // x为叶子数，m为非叶子节点度数。哈夫曼树又称最优树，它是带权路径长度最小的树，它仅有度为m和度为0的节点（叶子）。②每次选取频度最小的两个字符，分别作为左、右孩子（权重为频度）， O（n）选取1、2，作为左、右孩子，3作为父母节点。
哈夫曼树的介绍
最新发布
2301_76371717的博客
05-24 499
示例。
赫夫曼编码与解码
方亚军的博客
03-03 1330
赫夫曼编码 基本介绍 赫夫曼编码也翻译为哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法 赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。 赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%～90%之间 赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码 赫夫曼编码原理 通信领域中信息的处...
哈夫曼树、哈夫曼编码译码完整代码实现
曾续缘的博客
01-21 1474
从叶子结点自底向上判断该叶子结点是双亲的左孩子还是右孩子，如果是左孩子，记录0，如果是右孩子，记录１，直到回溯到根结点，翻转这些组合起来的0和１就是哈夫曼的编码。在哈夫曼树的每个分支上标上0或１：结点的左分支标0，右分支标１．把从根到每个叶子的路径上的标号连接起来，作为该叶子代表的字符的编码．。结点的带权路径长度：从根结点到该结点之间的路径长度与该结点的权的乘积．。路径：从树中一个结点到另一个结点之间的分支构成这两个结点间的路径。
数据结构（C语言）-哈夫曼（Huffman）树编码译码操作
qq_44025638的博客
11-17 1万+
huffman树的编码和译码操作
【数据结构】哈夫曼树
_Previous的博客
08-10 4081
1、背景知识 1、路径和路径长度 在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。 2、结点的权及带权路径长度 若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。 3、树
java哈夫曼树的编码解码.zip
11-10
在Java中实现哈夫曼树的编码和解码过程涉及以下几个主要步骤和概念： 1. **哈夫曼树构建**： - **哈夫曼节点**：每个节点代表一个字符，包含字符及其频率信息。 - **最小堆**：用于存储哈夫曼节点，每次取出频率...
C++实现哈夫曼树编码解码
12-20
哈夫曼树是一种特殊的二叉树，用于数据压缩和编码，通过构建最小带权路径长度（Minimum Weighted Path Length, MWPL）的树形结构来实现高效的数据编码和解码。在C++中，我们可以使用类来表示哈夫曼树的节点和整个树...
哈夫曼树解码编码.zip
07-12
该哈夫曼树解码编码基于数据结构（清华大学出版社）一书，读取要编码的文件data，然后再编码到code文件，最后再用code文件来解码，解码到result文件。（注意要把cpp文件和data放到同一个文件夹下运行，每运行完一次...
Python完成哈夫曼树编码过程及原理详解
09-18
主要介绍了Python完成哈夫曼树编码过程及原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
哈夫曼树编码解码.zip
06-14
资源包含文件：设计报告word+源码 采用 JavaSwing 进行 UI 界面搭建。详细介绍参考：https://blog.csdn.net/newlw/article/details/122642450
6.2哈夫曼树编码与解码
m0_65022800的博客
05-29 599
哈夫曼树相关的几个名词 路径：在一棵树中，一个结点到另一个结点之间的通路，称为路径。图 1 中，从根结点到结点 a 之间的通路就是一条路径。 路径长度：在一条路径中，每经过一个结点，路径长度都要加 1 。例如在一棵树中，规定根结点所在层数为1层，那么从根结点到第 i 层结点的路径长度为 i - 1 。图 1 中从根结点到结点 c 的路径长度为 3。 结点的权：给每一个结点赋予一个新的数值，被称为这个结点的权。例如，图 1 中结点 a 的权为 7，结点 b 的权为 5。 结点的带权路径长度：指的是从根结点到
HaffManTree哈夫曼树的编码和解码的个人学习心得感悟
寒雪无痕
05-20 2万+
HaffManTree哈夫曼树的编码和解码的个人学习心得感悟
（数据结构） 哈夫曼树的编码和解码简单的实现
weixin_45944348的博客
07-04 2919
输入一段英文原文，构造哈夫曼树，生成对应的编码表，输出原文对应的编码，或者是根据已经生成的编码表，输入一段二进制数编码，得到对应的字符原文。 #include<stdio.h> #include<iostream> #include<conio.h> #include<string.h> #include<stdlib.h> using namespace std; //哈夫曼树的存储表示 typedef struct{ int weight
哈夫曼树及哈夫曼编码详解【完整版代码】
热门推荐
wardseptember的博客
06-17 11万+
Huffman Tree简介&amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;nbsp; 赫夫曼树（Huffman Tree），又称最优二叉树，是一类带权路径长度最短的树。假设有n个权值{w1,w2,…,wn}，如果构造一棵有n个叶子节点的二叉树，而这n个叶子节点的权值是{w1,w2,…,wn}，则所构造出的带权路径长度最小的二叉树就被称为赫夫曼树。&amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;a
哈夫曼树构造与编码
x2656271356的博客
10-24 4957
哈夫曼树构造以及编码的实现
数据结构：哈夫曼树的建立与哈夫曼编码的实现
weixin_45888851的博客
07-15 8105
哈夫曼树 哈夫曼树，也称最优二叉树，是数据结构的一个重要内容，实际运用中我们通过哈夫曼编码来大幅度提高无损压缩的比例。 弄清哈夫曼树，我们首先要弄清以下四个概念。 概念1：什么是路径？ 在一棵树中，从一个结点到另一个结点所经过的所有结点，被我们称为两个结点之间的路径。 上面的二叉树当中，从根结点A到叶子结点H的路径，就是A，B，D，H。 概念2：什么是路径长度？ 在一棵树中，从一个结点到另一个结点所经过的“边”的数量，被我们称为两个结点之间的路径长度。 仍然用刚才的二叉树举例子，从根结点A到叶子结点H，
哈夫曼树编码与解码c++
05-05
下面是哈夫曼树的编码与解码的C语言实现： 先定义哈夫曼树的节点结构体： ```c typedef struct node { int weight; int parent; int lchild; int rchild; }HuffNode, *HuffTree; ``` 接着，定义哈夫曼树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值