数据结构C++——哈夫曼树及哈夫曼编码

最新推荐文章于 2024-06-12 22:59:37 发布
最新推荐文章于 2024-06-12 22:59:37 发布
阅读量5.8k 收藏 100
点赞数 12
分类专栏： 数据结构与算法分析 文章标签： 数据结构 算法 c++ 霍夫曼树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54162207/article/details/117397144
版权

数据结构C++——哈夫曼树及哈夫曼编码

文章目录

一、哈夫曼树的介绍及概念

哈夫曼(Huffman)树又称最优树，是一类带权路径长度最短的树，在实际中有广泛的用途。
(1) 路径：从树中一个结点到另一个结点之间的分支构成这两个结点之间的路径。
(2) 路径长度：路径上的分支数目称作路径长度。
(3)树的路径长度：从树根到每一结点的路径长度之和。
(4)权：赋予某个实体的一个量，是对实体的某个或某些属性的数值化描述。 在数据结构中，实体有结点（元素）和边（关系）两大类，所以对应有结点权和边权。 结点权或边权具体代表什么意义，由具体情况决定。如果在一棵树中的结点上带有权值，则对应的就有带权树等概念。
(5)结点的带权路径长度：从该结点到树根之间的路径长度与结点上权的乘积。
(6)树的带权路径长度：树中所有叶子结点的带权路径长度之和。
(7)哈夫曼树：假设有m个权值{w1, W2, …，匹}，可以构造一棵含n个叶子结点的二叉树，每个叶子结点的权为 W; 则其中带权路径长度 WPL最小的二叉树称做最优二叉树或哈夫曼树

二、哈夫曼树的构造及打印

①哈夫曼树的存储结构

哈夫曼树的存储结构

typedef struct {
   int weight;//结点的权值
   int parent, lchild, rchild;//结点的双亲、左孩子、右孩子的下标
}HTNode,*HuffmanTree;//动态分配数组存储哈夫曼树

②构造哈夫曼树

构造哈夫曼树

构造哈夫曼树的算法思路：
1：定义哈夫曼树变量，申请2*n个单元（0号单元未用），HT[2*n-1]表示根结点
2：定义变量m=2*n-1（一棵有n个叶子结点的哈夫曼树共有2*n-1个结点），循环m次，将1~m号中的的双亲、左孩子、右孩子、权重的下标都初始化为0
3：输入前n个单元中叶子结点的权值
4：在前n个单元中找到权值最小且双亲结点下标为0的结点，并返回它们在HT中的序号s1和s2
5：将s1和s2的双亲域由0改为i，s1和s2分别作为HT[i]的左右孩子，并修改HT[i]的权值为左右孩子的权值之和。

void CreateHuffmanTree(HuffmanTree& HT, int n) {
	//构造哈夫曼树
	if (n <= 1)
		return;
	int m = 2 * n - 1;//一棵有n个叶子节点的哈夫曼树共有2*n-1个结点
	HT = new HTNode[m + 1];//0号单元未用，所以需要动态分配m+1个单元，HT[m]表示根结点
	for (int i = 1; i <= m; i++)
	{//将1-m号单元中的双亲、左孩子、右孩子的下标都初始化为0
		HT[i].parent = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].weight = 0;
	}
	for (int i = 1; i <= n; i++) 
	{//输入前n个单元中叶子结点的权值
		cin >> HT[i].weight;
	}
	/*--------初始化工作结束，下面开始创建哈夫曼树------*/
	for (int i = n+1; i <= m; i++)
	{//通过n-1次的选择、删除、合并来创建哈夫曼树
		int s1=0, s2=0;
		Select(HT, i - 1, s1, s2);//在HT[k](1<=k<=i-1)中选择两个其双亲域为0且权值最小的结点，并返回它们在HT中的序号s1和s2
		HT[s1].parent = i; HT[s2].parent = i;
		//得到新结点i，从森林中删除s1,s2，将s1和s2的双亲域由0改为i
		HT[i].lchild = s1; HT[i].rchild = s2;//s1，s2分别作为i的左右孩子
		HT[i].weight = HT[s1].weight + HT[s2].weight;//i的权值为左右孩子权值之和
	}
}

③Select()函数的代码实现

Select()函数的实现
此步骤参照了此文章，即本步骤并非笔者纯原创：数据结构(15)–哈夫曼树以及哈夫曼编码的实现.

Select()函数代码实现思路：
1：设置中间变量tmp存放最小权值结点的权值
2：循环n次，找到权值最小的结点下标，将其赋予s1
3：重复第2步，找到权值最小但下标不为s1的结点下标，将其赋予s2

/*----------选择两个权值最小的结点-----------*/
void Select(HuffmanTree HT, int k, int& s1, int& s2) {
	unsigned int tmp = 10000;//假设s1对应的权值大于s2
	for (int i = 1; i <= k; i++)
	{
		if (!HT[i].parent)
		{//parent必须为0
			if (tmp>HT[i].weight)
			{
				tmp = HT[i].weight;//tmp存放权值最小的结点权值
				s1 = i;
			}
		}
	}
	unsigned int tmp1 = 10000;//假设s1对应的权值大于s2
	for (int i = 1; i <= k; i++)
	{
		if (!HT[i].parent&&i!=s1)
		{//parent必须为0
			if (tmp1 > HT[i].weight)
			{
				tmp1 = HT[i].weight;//tmp1存放权值最小的结点权值
				s2 = i;
			}
		}
	}
}

④打印哈夫曼树

打印哈夫曼树

打印哈夫曼树的算法思路：
1：将哈夫曼树以表格的形式输出更直观
2：输出表头i、weight、parent、lchild、rchild。
3：输出时注意C++函setw()的使用，注意左对齐为在setw()函数中加上std::left，右对齐则加上std::right。
4：循环2*n-1次输出构造好的哈夫曼树的每个结点的相关参数。

/*----------打印哈夫曼树---------*/
void PrintHuffmanTree(HuffmanTree HT,int m) {
	cout <<std::left << setw(10) << "i" << setw(10) << "weight" << setw(10) << "parent" << setw(10) << "lchild" << setw(10) << "rchild" << endl;
	for (int i = 1; i <= m; i++)
	{
		cout << setw(12) << i << setw(11) << HT[i].weight << setw(10) << HT[i].parent << setw(10) << HT[i].lchild << setw(10) << HT[i].rchild << endl;
	}
}

⑤测试的完整代码

完整代码

#include<iostream>
#include<iomanip>
using namespace std;
typedef struct {
	int weight;//结点的权值
	int parent, lchild, rchild;//结点的双亲、左孩子、右孩子的下标
}HTNode,*HuffmanTree;//动态分配数组存储哈夫曼树
/*----------选择两个权值最小的结点-----------*/
void Select(HuffmanTree HT, int k, int& s1, int& s2) {
	unsigned int tmp = 10000;//假设s1对应的权值大于s2
	for (int i = 1; i <= k; i++)
	{
		if (!HT[i].parent)
		{//parent必须为0
			if (tmp>HT[i].weight)
			{
				tmp = HT[i].weight;//tmp存放权值最小的结点权值
				s1 = i;
			}
		}
	}
	unsigned int tmp1 = 10000;//假设s1对应的权值大于s2
	for (int i = 1; i <= k; i++)
	{
		if (!HT[i].parent&&i!=s1)
		{//parent必须为0
			if (tmp1 > HT[i].weight)
			{
				tmp1 = HT[i].weight;//tmp1存放权值最小的结点权值
				s2 = i;
			}
		}
	}
}
/*-------构造哈夫曼树-------*/
void CreateHuffmanTree(HuffmanTree& HT, int n) {
	//构造哈夫曼树
	if (n <= 1)
		return;
	int m = 2 * n - 1;//一棵有n个叶子节点的哈夫曼树共有2*n-1个结点
	HT = new HTNode[m + 1];//0号单元未用，所以需要动态分配m+1个单元，HT[m]表示根结点
	for (int i = 1; i <= m; i++)
	{//将1-m号单元中的双亲、左孩子、右孩子的下标都初始化为0
		HT[i].parent = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].weight = 0;
	}
	for (int i = 1; i <= n; i++) 
	{//输入前n个单元中叶子结点的权值
		cin >> HT[i].weight;
	}
	/*--------初始化工作结束，下面开始创建哈夫曼树------*/
	for (int i = n+1; i <= m; i++)
	{//通过n-1次的选择、删除、合并来创建哈夫曼树
		int s1=0, s2=0;
		Select(HT, i - 1, s1, s2);//在HT[k](1<=k<=i-1)中选择两个其双亲域为0且权值最小的结点，并返回它们在HT中的序号s1和s2
		HT[s1].parent = i; HT[s2].parent = i;
		//得到新结点i，从森林中删除s1,s2，将s1和s2的双亲域由0改为i
		HT[i].lchild = s1; HT[i].rchild = s2;//s1，s2分别作为i的左右孩子
		HT[i].weight = HT[s1].weight + HT[s2].weight;//i的权值为左右孩子权值之和
	}
}
/*----------打印哈夫曼树---------*/
void PrintHuffmanTree(HuffmanTree HT,int m) {
	cout <<std::left << setw(10) << "i" << setw(10) << "weight" << setw(10) << "parent" << setw(10) << "lchild" << setw(10) << "rchild" << endl;
	for (int i = 1; i <= m; i++)
	{
		cout << setw(12) << i << setw(11) << HT[i].weight << setw(10) << HT[i].parent << setw(10) << HT[i].lchild << setw(10) << HT[i].rchild << endl;
	}
}
/*--------主函数--------*/
int main() {
	HuffmanTree HT = new HTNode;//定义一个哈夫曼树变量
	int n=0;
	cin >> n;//输入结点个数
	int m = 2 * n - 1;//m为哈夫曼树的所有结点的个数
	CreateHuffmanTree(HT, n);//构建一个哈夫曼树
	PrintHuffmanTree(HT, m);//输出哈夫曼树
}
//5 29 7 8 14

测试结果

输入：5
      5 29 7 8 14

输出结果

输出：

在这里插入图片描述
--------------------------------一道华丽的分割线-----------------------------------

二、哈夫曼编码

①哈夫曼编码的相关概念

(l)前缀编码：如果在一个编码方案中，任一个编码都不是其他任何编码的前缀（最左子串），则称编码是前缀编码。例如：0，10，110，111是前缀编码，而0，01，010，111就不是前缀编码，前缀编码可以保证对压缩文件进行解码时不产生二义性， 确保正确解码。
(2) 哈夫曼编码：对一棵具有n个叶子的哈夫曼树，若对树中的每个左分支赋予0, 右分支赋予1’则从根到每个叶子的路径上，各分支的赋值分别构成一个二进制串， 该二进制串就称为哈夫曼编码。

②哈夫曼编码的算法实现

算法思路

在构造哈夫曼树之后，求哈夫曼编码的主要思想是：依次以叶子为出发点，向上回溯至根结
点为止。 回溯时走左分支则生成代码 0, 走右分支则生成代码l。

哈夫曼编码表的存储表示

/*----------哈夫曼编码表的存储表示------------*/
typedef char** HuffmanCode;//动态分配数组存储哈夫曼编码表

根据哈夫曼树求哈夫曼编码

根据哈夫曼树求哈夫曼编码的算法思路：
1：定义HC指针数组，数组的每一个单元存储一个指针，定义cd数组，临时存储每一个叶子结点的字符编码
2：遍历n个叶子结点，从叶子结点开始向上回溯，直到根结点
3：若c为回溯到的父结点的左子树的根结点，则生成代码0
4：若c为回溯到的父结点的右子树的根结点，则生成代码1
5：回溯一次start向前指一个位置，最后cd数组中实际存值的单元为start~n-1这段单元
6：最后将求得的编码从临时空间cd复制到HC的当前行中

/*---------根据哈夫曼树求哈夫曼编码------------*/
void CreatHuffmanCode(HuffmanTree HT, HuffmanCode& HC, int n) {
	//从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
	HC = new char* [n + 1];//分配存储n个字符编码的编码表空间
	char* cd = new char[n];//分配临时存放每个字符编码的动态数组空间
	cd[n - 1] = '\0';//编码结束符
	for (int i = 1; i <= n; i++) {
		int start = n - 1;//start开始时指向最后，即编码结束符位置
		int c = 0 , f = 0;
		c = i; f = HT[i].parent;//f指向结点c的双亲结点
		while (f!=0)//从叶子结点开始向上回溯，直到根结点
		{
			--start;//回溯一次start向前指一个位置
			if (HT[f].lchild == c) cd[start] = '0';//结点c是f的左孩子，则生成代码0
			else cd[start] = '1';//结点c是f的右孩子，则生成代码1
			c = f; f = HT[f].parent;//继续向上回溯
		}//求出第i个字符的编码
		HC[i] = new char[n - start];
		strcpy(HC[i], &cd[start]);//将求得的编码从临时空间cd复制到HC的当前行中
	}
	delete cd;//释放临时空间
}

③输出哈夫曼编码

将哈夫曼编码的结果输出在控制台

输出哈夫曼编码的算法思路：
1：输出表头
2：循环n次将HC数组中的内容输出

/*--------输出哈夫曼编码-----------*/
void PrintfHuffmanCode(HuffmanCode& HC, int n) {
	//将哈夫曼编码的结果输出在控制台
	cout << std::left << setw(10) << "i" << std::left << setw(10) << "编码" << endl;
	for (int i = 1; i <= n; i++) {
		cout << std::left << setw(10) << i;
		string str = HC[i];
		cout << std::left << setw(10) << str << endl;
	}
}

④测试的完整代码

#include<iostream>
#include<iomanip>
#include<string>
using namespace std;
/*----------哈夫曼编码表的存储表示------------*/
typedef char** HuffmanCode;//动态分配数组存储哈夫曼编码表
typedef struct {
	int weight;//结点的权值
	int parent, lchild, rchild;//结点的双亲、左孩子、右孩子的下标
}HTNode,*HuffmanTree;//动态分配数组存储哈夫曼树
/*----------选择两个权值最小的结点-----------*/
void Select(HuffmanTree HT, int k, int& s1, int& s2) {
	unsigned int tmp = 10000;//假设s1对应的权值大于s2
	for (int i = 1; i <= k; i++)
	{
		if (!HT[i].parent)
		{//parent必须为0
			if (tmp>HT[i].weight)
			{
				tmp = HT[i].weight;//tmp存放权值最小的结点权值
				s1 = i;
			}
		}
	}
	unsigned int tmp1 = 10000;//假设s1对应的权值大于s2
	for (int i = 1; i <= k; i++)
	{
		if (!HT[i].parent&&i!=s1)
		{//parent必须为0
			if (tmp1 > HT[i].weight)
			{
				tmp1 = HT[i].weight;//tmp1存放权值最小的结点权值
				s2 = i;
			}
		}
	}
}
/*-------构造哈夫曼树-------*/
void CreateHuffmanTree(HuffmanTree& HT, int n) {
	//构造哈夫曼树
	if (n <= 1)
		return;
	int m = 2 * n - 1;//一棵有n个叶子节点的哈夫曼树共有2*n-1个结点
	HT = new HTNode[m + 1];//0号单元未用，所以需要动态分配m+1个单元，HT[m]表示根结点
	for (int i = 1; i <= m; i++)
	{//将1-m号单元中的双亲、左孩子、右孩子的下标都初始化为0
		HT[i].parent = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].weight = 0;
	}
	for (int i = 1; i <= n; i++) 
	{//输入前n个单元中叶子结点的权值
		cin >> HT[i].weight;
	}
	/*--------初始化工作结束，下面开始创建哈夫曼树------*/
	for (int i = n+1; i <= m; i++)
	{//通过n-1次的选择、删除、合并来创建哈夫曼树
		int s1=0, s2=0;
		Select(HT, i - 1, s1, s2);//在HT[k](1<=k<=i-1)中选择两个其双亲域为0且权值最小的结点，并返回它们在HT中的序号s1和s2
		HT[s1].parent = i; HT[s2].parent = i;
		//得到新结点i，从森林中删除s1,s2，将s1和s2的双亲域由0改为i
		HT[i].lchild = s1; HT[i].rchild = s2;//s1，s2分别作为i的左右孩子
		HT[i].weight = HT[s1].weight + HT[s2].weight;//i的权值为左右孩子权值之和
	}
}
/*---------根据哈夫曼树求哈夫曼编码------------*/
void CreatHuffmanCode(HuffmanTree HT, HuffmanCode& HC, int n) {
	//从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
	HC = new char* [n + 1];//分配存储n个字符编码的编码表空间
	char* cd = new char[n];//分配临时存放每个字符编码的动态数组空间
	cd[n - 1] = '\0';//编码结束符
	for (int i = 1; i <= n; i++) {
		int start = n - 1;//start开始时指向最后，即编码结束符位置
		int c = 0 , f = 0;
		c = i; f = HT[i].parent;//f指向结点c的双亲结点
		while (f!=0)//从叶子结点开始向上回溯，直到根结点
		{
			--start;//回溯一次start向前指一个位置
			if (HT[f].lchild == c) cd[start] = '0';//结点c是f的左孩子，则生成代码0
			else cd[start] = '1';//结点c是f的右孩子，则生成代码1
			c = f; f = HT[f].parent;//继续向上回溯
		}//求出第i个字符的编码
		HC[i] = new char[n - start];
		strcpy(HC[i], &cd[start]);//将求得的编码从临时空间cd复制到HC的当前行中
	}
	delete cd;//释放临时空间
}
/*--------将哈夫曼编码的结果输出在控制台-----------*/
void PrintfHuffmanCode(HuffmanCode& HC, int n) {
	//将哈夫曼编码的结果输出在控制台
	//char* cd = new char[n];
	cout << std::left << setw(10) << "i" << std::left << setw(10) << "编码" << endl;
	for (int i = 1; i <= n; i++) {
		cout << std::left << setw(10) << i;
		string str = HC[i];
		cout << std::left << setw(10) << str << endl;
	}
}
/*--------主函数--------*/
int main() {
	HuffmanTree HT = new HTNode;//定义一个哈夫曼树变量
	int n=0;
	cin >> n;//输入结点个数
	int m = 2 * n - 1;//m为哈夫曼树的所有结点的个数
	CreateHuffmanTree(HT, n);//构建一个哈夫曼树
	//PrintHuffmanTree(HT, m);//输出哈夫曼树
	HuffmanCode HC;
	CreatHuffmanCode(HT, HC, n);
	PrintfHuffmanCode(HC, n);
	return 0;
}

输出结果

输入：
8
5 29 7 8 14 23 3 11

输出：

在这里插入图片描述

三、总结

以上为笔者对于哈夫曼树及哈夫曼编码的一些见解，希望初学者都能有所收获，有技术不到位的地方，还望各位大佬指正。
同时，笔者的个人主页还有数据结构中其他部分的一些见解与分析，后续数据结构的相关知识还将陆续更新，欢迎大家访问且共同学习！

近景_
关注
  • 12
    点赞
  • 踩
  • 100
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
C语言数据结构学习笔记(15)-哈夫曼树的创建及哈夫曼编码
laven_li的博客
11-07 1799
/* 哈夫曼编码 输出结果: 请输入初始结点个数:5 请输入5个权值:2 5 7 8 6 最小元素为2下标为0, 次小元素为5下标为1 最小元素为6下标为4, 次小元素为7下标为2 最小元素为7下标为5, 次小元素为8下标为3 最小元素为13下标为6, 次小元素为15下标为7 下标 weight parent lchild rchild 0 2 5 -1 -1 1 5 5 -1 -1 2 7 ...
数据结构——哈夫曼树与哈夫曼编码
ZDF19的博客
12-27 611
1.哈夫曼编码 Huffman code:   是一种文本压缩算法，这种算法依据的是不同符号在一段文本中相对出现的频率。假设一个文本是由a,u,x,z组成的字符串，其长度为1000，每个字符用1字节来存储，共需要1000字节，即8000位。如果每个字符用2位二进制来编码：00=a, 01=x, 10=u, 11=z.那么，用2000位空间即课表示1000个字符。此外，我们还需要一定的空间来存放编
C++ 哈夫曼编码
ChanJose的博客
03-13 2万+
1.哈夫曼编码的结点类： struct HuffmanNode { int weight; // 权重，出现的次数或者频率 char ch; // 存储符号 string code; // 存储该符号对应的编码 int leftChild, rightChild, parent; // 左、右孩子，父结点 }; 2.思路： （1）统计输入的字符串中不同字...
C++实现哈夫曼编码、解码
qq_45285738的博客
03-09 577
第二部分打印出来的是，测试数据 A B C D E F G 的对应编码，这里可以自行扩充。第一部分打印出来的是 哈夫曼树 的结构。第三部分是用于测试的解码结果。
数据结构复习笔记5.6：哈夫曼编码树
最新发布
2301_81070376的博客
06-12 570
有了哈夫曼编码树的特性，我们也知道了哈夫曼树的构造过程，最后我们再来看⼀个哈夫曼编 码和哈夫曼树构造的完整过程。
C++实现构造哈夫曼、哈夫曼编码
qq_44757691的博客
12-09 2313
例：设n=7，w={0.4,0.3,0.15,0.05,0.04,0.03,0.03}构造哈夫曼树，并求哈夫曼编码。
哈夫曼树与哈夫曼编码
Eamon
04-07 3729
Huffman Tree，中文名是哈夫曼树或霍夫曼树，它是最优二叉树。 引入 如果有一篇文章，由若干个字符构成。每个ABC…Z都由7位编码，文章有1w个字符，那么有7w位进行编码。一个字节8位，首位是0。需要占用1W个字节。 实际中每个单词的出现频率是不同的，比如e在文章中出现频率较高，我用5位给它编码，出现频率较低的使用7位、8位或者9位。这样效率会得到提高。 看一个具体的例子： 将百分制的成绩...
哈夫曼树和哈夫曼编码
m0_74787322的博客
06-11 292
基本术语1、路径和路径长度在一棵树中存在着一个节点序列K1,K2,K3…Kj,使得Ki是Ki+1的双亲，则称此节点序列是从K1~Kj的路径，因为树中每个节点只有一个双亲节点，所以他也是这两个之间的唯一路径，从K1~Kj所经过的分支数称为这两个节点之间的路径长度，他等于路径上的节点数减1.2、节点权和带权路径度在许多应用中将树中的节点赋值一个有意义的实数，称此实数为该节点的权，节点的带权路径长度规定为从树根节点到该节点之间的路径长度与该节点权的乘积。3、树的带权路径长度。
数据结构与算法（6-5）二叉树的应用--哈夫曼树与哈夫曼编码
great_yzl的博客
08-02 918
目录 哈夫曼编码（最优二叉树） 优势：缩短电文长度 思想： 过程： 图解实现过程： 总代码 哈夫曼编码（最优二叉树） 一、优势：缩短电文长度 二、思想： 获取每个字符出现的频率，用一个大小为[256]的数组保存（因为ASCII码是256个），最后作为每个字符的权重。权重越大，意味着出现频率越大，希望它的码长越短，这样总体电文最小。最后把这些字符（不重复部分）、权重依次放入结点中，把这些结点作为一个个元素，从小到大依次组成哈夫曼树。 三、过程： 先统...
哈夫曼树（Huffman Tree）及哈夫曼编码（Huffman Coding）
lranqi的博客
07-28 1万+
哈夫曼树(Huffman Tree)又称最优二叉树，给定N个权值作为N个叶子结点，构造一棵二叉树，使该树的带权路径长度达到最小。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）。 本文所有概念性描述及图示均来自王道考研数据结构。...
哈夫曼树以及哈夫曼编码
qq_52607834的博客
06-06 4272
震惊！原来哈夫曼编码还能这样玩
【数据结构】哈夫曼树及哈夫曼编码实现（C语言）
热门推荐
weixin_51450101的博客
02-12 6万+
目录1. 哈夫曼树1.1 基本概念1.2 构造哈夫曼树1.3 哈夫曼树的类型定义1.4 哈夫曼树创建的算法实现2. 哈夫曼编码实现2.1 哈夫曼编码2.2 完整代码2.3 运行结果 1. 哈夫曼树 1.1 基本概念 路径：指从根结点到该结点的分支序列。 路径长度：指根结点到该结点所经过的分支数目。 结点的带权路径长度：从树根到某一结点的路径长度与该结点的权的乘积。 树的带权路径长度(WPL)：树中从根到所有叶子结点的各个带权路径长度之和。 哈夫曼树是由 n 个带权叶子结点构成的所有二叉树中带权路径长度最短的
C++数据结构之文件压缩（哈夫曼树）实例详解
01-01
C++数据结构之文件压缩（哈夫曼树）实例详解 概要： 项目简介：利用哈夫曼编码的方式对文件进行压缩，并且对压缩文件可以解压 开发环境：windows vs2013 项目概述：  1.压缩  a.读取文件，将每个字符，该字符出现...
哈夫曼编码压缩和解压缩文件——C++实现
01-20
哈夫曼编码是一种数据压缩方法，它通过构建最优的二叉树（哈夫曼树）来为字符分配编码，使得最频繁出现的字符拥有最短的编码，从而达到压缩数据的目的。在C++中实现哈夫曼编码压缩和解压缩文件涉及到几个关键步骤： ...
哈夫曼树与哈夫曼编码详解及C++模板实现共13页.pdf
10-30
哈夫曼编码是一种前缀编码方法，通过构建特殊的二叉树结构——哈夫曼树，来为每个字符分配一个独一无二的二进制码，使得频繁出现的字符具有较短的编码，从而达到高效压缩数据的目的。 哈夫曼树的构建过程分为两个...
数据结构课程设计——哈夫曼编/译码器
11-26
初始化 从终端读入字符集大小n及n个字符和m个权值，建立哈夫曼树，并将它存于文件hfmtree中 编码 利用已建好的哈夫曼树（如不在内存，则从文件hfmtree中读入），对文件tobetrans中的正文进行编码，然后将结果存入...
重庆大学数据结构项目2——哈夫曼编码树
01-07
《哈弗曼编码树在数据结构中的应用：重庆大学项目解析》 在计算机科学领域，数据结构是构建高效算法的基础，而哈弗曼编码作为一项关键的编码技术，广泛应用于数据压缩、信息传输等领域。本项目是重庆大学数据结构...
哈夫曼树（Huffman tree）及哈夫曼编码
cyq6239075的博客
06-13 9785
基本术语 1、路径和路径长度 在一棵树中存在着一个节点序列K1,K2,K3…Kj,使得Ki是Ki+1的双亲，则称此节点序列是从K1~Kj的路径，因为树中每个节点只有一个双亲节点，所以他也是这两个之间的唯一路径，从K1~Kj所经过的分支数称为这两个节点之间的路径长度，他等于路径上的节点数减1. 2、节点权和带权路径度 在许多应用中将树中的节点赋值一个有意义的实数，称此实数为该节点的权，节点的带权路径长度规定为从树根节点到该节点之间的路径长度与该节点权的乘积。 3、树的带权路径长度 树的带权路径长度
[C++数据结构](31)哈夫曼树，哈夫曼编码与解码
CegghnnoR的博客
10-28 4138
哈夫曼树又称最优二叉树，它是由 n 个带权叶子结点构成的所有二叉树中带权路径长度 WPL 最短的二叉树。其具有叶结点权值越小，离根越远，叶结点权值越大，离根越近的特点，此外其仅有叶结点的度为0 ，其他结点度均为2。
c++哈夫曼树及哈夫曼编码
05-03
哈夫曼树（Huffman Tree）是一种特殊的二叉树，用于压缩数据，常用于数据传输和存储中。哈夫曼编码（Huffman Coding）则是一种基于哈夫曼树的编码方式，可以将字符或数据压缩成更短的二进制序列，从而节省存储空间和传输时间。 哈夫曼树的构建过程如下： 1. 统计每个字符出现的频率，并将它们作为叶子节点的权值。 2. 将所有权值列表按照从小到大的顺序排序。 3. 取出权值最小的两个节点（可以是叶子节点，也可以是非叶子节点）作为左右子节点，它们的父节点的权值为左右子节点的权值之和。 4. 将新生成的父节点插入到权值列表中，并按照权值大小重新排序。 5. 重复步骤3和步骤4，直到只剩下一个节点，此节点即为根节点，构成哈夫曼树。 构建完成后，每个字符对应的编码可以通过从根节点到叶子节点的路径上的0和1来表示。从根节点出发，左儿子表示为0，右儿子表示为1，最终到达叶子节点所经过的路径就是该字符的哈夫曼编码。 哈夫曼编码可以达到无损压缩的效果，因为每个字符都有唯一的编码，解压时只需根据编码从根节点出发，沿着路径找到对应的叶子节点即可还原原始字符。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

近景_

打赏拉满，动力满满

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值