树：哈夫曼树和哈夫曼编码的详细介绍以及代码实现

最新推荐文章于 2024-08-07 15:31:00 发布
最新推荐文章于 2024-08-07 15:31:00 发布
阅读量6.8k 收藏 38
点赞数 10
分类专栏： 【C/C++编程】 【数据结构】 文章标签： 哈夫曼树 哈夫曼编码 赫夫曼树 赫夫曼编码 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29542611/article/details/79334308
版权

闲扯前言

哈夫曼编码的代码实现对于初学数据结构的同学可能会有些困难，没有必要灰心，其实没啥，学习就犹如攀登一座又一座的山峰，每当我们攻克一个难点后，回首来看，也不过如此嘛。我们要做的就是不断的去攀越学习上的山峰 不断的超越过去的自己。尤其是我们程序员，不进则退，中国最不缺的就是人，肯定不缺替代你的程序员，没有越老越吃香的程序员，中国的老程序员都去哪了？要么转管理，要么被淘汰转行了，当然还有一小部分成为技术专家 继续活跃在IT圈。时代在进步，技术在不断换代的更新，但是计算机一些固有的东西仍没有改变，编程语言只是我们手中的武器，我们唯有把内功修炼好，然后拿着利器 可以无往不胜！数据结构和算法就是我们程序员的内功修炼的一方面。不扯淡了。。。下面是博主如何攻克哈夫曼树和哈夫曼编码的一些思路。参考教材为 大话数据结构。

哈夫曼树和哈夫曼编码的关系

哈夫曼树当然是一种树，不过这种树有些特殊之处。哈夫曼编码呢，是根据哈夫曼树规则生成的编码！提供一个字符，根据哈夫曼编码规则，你会得到一个哈夫曼编码，不过你提供的字符必须在哈夫曼编码表中有对应的编码才行。

哈夫曼树

哈夫曼大叔说，从树中一个结点到另一个结点之间的分支构成2个结点之间的路径，路劲上的分支数目称作路径长度。树的路径长度就是从树根到每一结点的路径长度之和。如果考虑到带权的结点，结点的带权的路径长度就为从该结点到树根之间的路径长度与结点上权的乘积。树的带权路径长度为树中所有叶子结点的带权路径长度之和。

假设有n个权值{W1,W2.....,Wn}，构造一棵n个叶子结点的二叉树，每个叶子结点带权Wk，每个叶子的路径长度为1k，我们通常记作，其中带权路径长度WPL最小的二叉树称为哈夫曼树（又称最优二叉树）。

定义我们只要有理解就ok，重点是下面如何构建哈夫曼树！

哈夫曼树构造步骤

  1. 根据给定的n个权值{W1,W2,...,Wn}构成n棵二叉的集合F={T1,T2,...Tn}，其中每棵二叉树Ti只有一个带权为Wi的根结点，其左右子树均为空。
  2. 在F中选取2棵根结点最小的树 作为左右子树 构造一棵新的二叉树，且新的二叉树的根结点左右子树根结点权值之和。
  3. 在F中删除这2棵子树，同时将新得到的二叉树加入F中。
  4. 重复2和3步骤，直到F只含一棵树为止，这棵树便是哈夫曼树。
我们看这4个步骤，能否联想到队列的出队入队呢？往队列方向想，思路是对的。将权值最小的2棵树节点出队，然后创建新结点入队，这样一直循环，最后剩下那一个树结点时不就是哈夫曼树么。下面是构建哈夫曼树的HuffQueue.h的相关接口和数据结构。代码汇总在最后。

HuffQueue.h

#pragma once 
#ifndef __HUFFQUEUE_H__
#define __HUFFQUEUE_H__
#include "HuffmanTree.h"

//哈夫曼结点的队列 结点的数据结构
typedef struct HuffQueueNode
{
	HuffmanNode* treeNode;//哈夫曼树结点
	int weightNum;//权值
	struct HuffQueueNode* next;//指向下一个结点
}HuffQueueNode;

//哈夫曼结点组成的队列数据结构，由于插入数据（根据权值）和删除数据（删除队头的数据）的特性，需要结点个数 和 头指针
typedef struct HuffQueue
{
	int size;
	HuffQueueNode* first;
}HuffQueue;

//初始化队列
void InitHuffQueue(HuffQueue** queue);

//获取结点（出队操作），从队头出队
HuffQueueNode* GetHuffQueueNode(HuffQueue* queue);

//插入结点（入队操作），特殊插入 根据权值大小进行有序的插入结点 非结尾处插入
void AddHuffQueueNode(HuffQueue* queue, HuffmanNode* treeNode, int weightNum);


#endif // !__HUFFQUEUE_H__

BuildHuffmanTree函数

//根据用户提供字符集，生成对应的哈夫曼树
HuffmanTree BuildHuffmanTree(char* inputString)
{
	//统计每个字符出现的权值
	int charWeight[MAX_SZ] = { 0 };
	for (int i = 0; i < inputString[i]!='\0'; i++)
	{
		charWeight[(unsigned char)inputString[i]]++;
	}
	HuffQueue* queue = NULL;
	InitHuffQueue(&queue);

	for (int i = 0; i <MAX_SZ; i++)
	{
		//对应的字符有权值，创建树结点，添加到树节点队列中
		if (charWeight[i])
		{
			HuffmanNode* treeNode = (HuffmanNode*)malloc(sizeof(HuffmanNode));
			treeNode->data = i;
			treeNode->lchild = treeNode->rchild = NULL;
			AddHuffQueueNode(queue, treeNode, charWeight[i]);
		}
	}
	//根据哈夫曼树创建原理构建哈夫曼树
	//核心就是将权值最小的2个结点，取出作为新创建树结点的孩子结点，新创建树结点的权值为它们之和，然后放回树结点队列
	//一直这样循环进行操作，直到队列中最后剩一个结点，它就是树的根结点。
	while (queue->size != 1)
	{
		HuffQueueNode* node1 = GetHuffQueueNode(queue);
		HuffQueueNode* node2 = GetHuffQueueNode(queue);
		HuffmanNode* treeNode = (HuffmanNode*)malloc(sizeof(HuffmanNode));
		treeNode->data = '\0';
		treeNode->lchild = node1->treeNode;
		treeNode->rchild = node2->treeNode;
		int weightNum = node1->weightNum + node2->weightNum;
		AddHuffQueueNode(queue, treeNode, weightNum);
	}
	return queue->first->treeNode;
}

哈夫曼编码

定义还是先过一遍！一般地，设需要编码的字符集为{d1,d2,...dn}，各个字符在电文中出现的次数或者频率集合{W1,W2,...Wn},以d1,d2,...dn作为叶子结点，以W1,W2,...Wn作为相应叶子结点的权值来构造一棵哈夫曼树。规定哈夫曼树的左分支代表0，右分支代表1，则从根结点到叶子结点所经过的路劲分支组成的0和1的序列便为该结点对应字符的编码，这就是哈夫曼编码。

后面一句话是重点！走到叶子结点经过的0101...就是对应字符的哈夫曼编码！

有了哈夫曼树，写哈夫曼编码表 就很好，编写了！看下哈夫曼编码表的数据结构采用链式队列的方式，这样是否更方便！数据结构是我们人为去定义，是为我们操作数据提供方便的。下面是 HuffmanTree.h提供的相关接口和相应的数据结构。代码汇总在最后。

HuffmanTree.h

#pragma once 
#ifndef __HUFFMANTREE_H__
#define __HUFFMANTREE_H__

//创建哈夫曼树提供的字符的最大长度
#define MAX_SZ 256
//哈夫曼编码字符串最大长度
#define MAX_ENCODE 1024
//哈夫曼树结点数据结构
typedef struct HuffmanNode
{
	char data;
	struct HuffmanNode *lchild, *rchild;
}HuffmanNode,*HuffmanTree;

//哈夫曼编码表结点数据结构
typedef struct HuffmanTableNode
{
	char data;		//字符
	char *encode;	//字符对应的哈夫曼编码
	struct HuffmanTableNode *next;
}HuffmanTableNode;
//哈夫曼编码表数据结构
typedef struct HuffmanTable
{
	HuffmanTableNode* front;//指向队头元素
	HuffmanTableNode* tail;	//指向队尾元素
}HuffmanTable;

//根据用户提供原始数据，生成对应的哈夫曼树
HuffmanTree BuildHuffmanTree(char* inputString);

//根据哈夫曼树 生成对应的哈夫曼编码表
HuffmanTable* BuildHuffmanTable(HuffmanTree tree);

//对用户提供的源字符进行哈夫曼编码
char* encode(HuffmanTable* table, char* src);

//根据用户提供的哈夫曼编码进行解码
char* decode(HuffmanTree root, char* encode);

//遍历哈夫曼编码表
void TraverseHuffmanTable(HuffmanTable* table);
#endif // !__HUFFMANTREE_H__

BuildHuffmanTable函数

/*
递归遍历哈夫曼树
depth 树的深度
tree 哈夫曼树
hTable 哈夫曼编码表
encode 字符对应的哈夫曼编码
*/
void traverseHuffTree(HuffmanTable* hTable,HuffmanTree tree,char* encode,int depth)
{
	
	if (NULL == tree->lchild && NULL == tree->rchild)
	{
		HuffmanTableNode* tableNode = (HuffmanTableNode*)malloc(sizeof(HuffmanTableNode));
		tableNode->data = tree->data;
		tableNode->next = NULL;
		encode[depth] = '\0';
		tableNode->encode = (char*)malloc(depth+1);
		strcpy(tableNode->encode, encode);
		if (hTable->front == NULL)
		{
			hTable->front = hTable->tail = tableNode;
		}
		else
		{
			hTable->tail->next = tableNode;
			hTable->tail = tableNode;
		}
	}
	if (NULL != tree->lchild)
	{
		encode[depth] = '0';//左分支代表0
		traverseHuffTree(hTable, tree->lchild, encode, depth+1);
	}

	if (NULL != tree->rchild)
	{
		encode[depth] = '1';//右分支代表1
		traverseHuffTree(hTable, tree->rchild, encode, depth+1);
	}
	return;
}

//根据哈夫曼树生成哈夫曼编码表
HuffmanTable * BuildHuffmanTable(HuffmanTree tree)
{
	HuffmanTable* hTable = (HuffmanTable*)malloc(sizeof(HuffmanTable));
	hTable->front = hTable->tail = NULL;
	char encode[MAX_SZ] = { 0 };
	traverseHuffTree(hTable, tree, encode, 0);
	return hTable;
}

哈夫曼树和哈夫曼编码的使用

既然有了哈夫曼编码，那么就可以进行对用户提供的字符集进行哈夫曼编码了哟，当然也可用利用用户提供的哈夫曼编码进行解码咯。这就是小case了，encode 编码：根据用户提供的字符到哈夫曼编码表中找到对应的哈夫曼编码然后返回给用户就可以了。decode解码：用户提供01100等哈夫曼编码，利用哈夫曼树进行解码就ok，0就往左走，1就往右走，直到叶子结点 对应的字符不就出来了么，然后又从哈夫曼树根结点开始走，直到将哈夫曼编码走完。下面是encode和decode代码。

encode函数

char* encode(HuffmanTable* table,char* src)
{
	char* encode = (char*)calloc(sizeof(char)*MAX_ENCODE,1);
	for (int i = 0; i < src[i]!='\0'; i++)
	{
		char ch = src[i];
		HuffmanTableNode* iterator = table->front;
		while (iterator != NULL)
		{
			if (iterator->data == ch)
			{
				strcat(encode, iterator->encode);
				break;
			}
			iterator = iterator->next;
		}
		if (iterator == NULL)
		{
			printf("哈夫曼编码表中没有字符%c对应的哈夫曼编码！\n",ch);
			return NULL;
		}
	}
	return encode;
}

decode函数

//根据用户提供的哈夫曼编码进行解码
char* decode(HuffmanTree root,char* encode)
{
	char* decode = (char*)calloc(MAX_SZ, 1);
	HuffmanTree tree = root;
	for (int i = 0; i < encode[i]!='\0'; i++)
	{
		char ch = encode[i];
		if ('0' == ch)//0 往左走
		{
			tree = tree->lchild;
		}
		else//1 往右走
		{
			tree = tree->rchild;
		}
		//走到头，也就是找到相应的 源字符了
		if (tree->lchild == NULL && tree->rchild == NULL)
		{
			strncat(decode, &tree->data, 1);
			//找到字符后，树节点回到根结点，继续解码
			tree = root;
		}
	}
	return decode;
}

代码汇总一览

HuffQueue.h

#pragma once 
#ifndef __HUFFQUEUE_H__
#define __HUFFQUEUE_H__
#include "HuffmanTree.h"

//哈夫曼结点的队列 结点的数据结构
typedef struct HuffQueueNode
{
	HuffmanNode* treeNode;//哈夫曼树结点
	int weightNum;//权值
	struct HuffQueueNode* next;//指向下一个结点
}HuffQueueNode;

//哈夫曼结点组成的队列数据结构，由于插入数据（根据权值）和删除数据（删除队头的数据）的特性，需要结点个数 和 头指针
typedef struct HuffQueue
{
	int size;
	HuffQueueNode* first;
}HuffQueue;

//初始化队列
void InitHuffQueue(HuffQueue** queue);

//获取结点（出队操作），从队头出队
HuffQueueNode* GetHuffQueueNode(HuffQueue* queue);

//插入结点（入队操作），特殊插入 根据权值大小进行有序的插入结点 非结尾处插入
void AddHuffQueueNode(HuffQueue* queue, HuffmanNode* treeNode, int weightNum);


#endif // !__HUFFQUEUE_H__

HuffQueue.c

#include "HuffQueue.h"
#include <stdlib.h>

//初始化队列
void InitHuffQueue(HuffQueue** queue)
{
	*queue = (HuffQueue*)malloc(sizeof(HuffQueue));
	(*queue)->size = 0;
	(*queue)->first = NULL;
}

//获取结点（出队操作），只需要树节点的数据，故只返回树节点数据
HuffQueueNode* GetHuffQueueNode(HuffQueue* queue)
{
	if (NULL == queue || 0 == queue->size || NULL == queue->first)
	{
		return NULL;
	}
	HuffQueueNode* queueNode = queue->first;
	queue->first = queue->first->next;
	queue->size--;
	return queueNode;

}

//插入结点（入队操作），特殊插入 根据权值大小进行有序的插入结点 非队尾处插入
void AddHuffQueueNode(HuffQueue* queue, HuffmanNode* treeNode, int weightNum)
{
	HuffQueueNode *queueNode = (HuffQueueNode*)malloc(sizeof(HuffQueueNode));
	queueNode->weightNum = weightNum;
	queueNode->treeNode = treeNode;
	queueNode->next = NULL;
	//队列为空
	if (0 == queue->size)
	{
		queue->first = queueNode;
		queue->size++;
		return;
	}
	else
	{
		//比第一个结点权值都小
		if (weightNum < queue->first->weightNum)
		{
			queueNode->next = queue->first;
			queue->first = queueNode;
			queue->size++;
			return;
		}

		HuffQueueNode* iterator = queue->first;
		HuffQueueNode* pre = NULL;
		while (iterator != NULL && weightNum > iterator->weightNum)
		{
			pre = iterator;
			iterator = iterator->next;
		}
		//在队列中找到自己位置，将其插入其中
		if (NULL != iterator)
		{
			queueNode->next = iterator->next;
			iterator->next = queueNode;
		}
		//没找到，说明自己权值最大，插入到末尾
		else
		{
			pre->next = queueNode;
		}
		queue->size++;
		return;
	}
	return;
}

HuffmanTree.h

#pragma once 
#ifndef __HUFFMANTREE_H__
#define __HUFFMANTREE_H__

//创建哈夫曼树提供的字符的最大长度
#define MAX_SZ 256
//哈夫曼编码字符串最大长度
#define MAX_ENCODE 1024
//哈夫曼树结点数据结构
typedef struct HuffmanNode
{
	char data;
	struct HuffmanNode *lchild, *rchild;
}HuffmanNode,*HuffmanTree;

//哈夫曼编码表结点数据结构
typedef struct HuffmanTableNode
{
	char data;		//字符
	char *encode;	//字符对应的哈夫曼编码
	struct HuffmanTableNode *next;
}HuffmanTableNode;
//哈夫曼编码表数据结构
typedef struct HuffmanTable
{
	HuffmanTableNode* front;//指向队头元素
	HuffmanTableNode* tail;	//指向队尾元素
}HuffmanTable;

//根据用户提供原始数据，生成对应的哈夫曼树
HuffmanTree BuildHuffmanTree(char* inputString);

//根据哈夫曼树 生成对应的哈夫曼编码表
HuffmanTable* BuildHuffmanTable(HuffmanTree tree);

//对用户提供的源字符进行哈夫曼编码
char* encode(HuffmanTable* table, char* src);

//根据用户提供的哈夫曼编码进行解码
char* decode(HuffmanTree root, char* encode);

//遍历哈夫曼编码表
void TraverseHuffmanTable(HuffmanTable* table);
#endif // !__HUFFMANTREE_H__

HuffmanTree.c

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "HuffmanTree.h"
#include "HuffQueue.h"

//根据用户提供字符集，生成对应的哈夫曼树
HuffmanTree BuildHuffmanTree(char* inputString)
{
	//统计每个字符出现的权值
	int charWeight[MAX_SZ] = { 0 };
	for (int i = 0; i < inputString[i]!='\0'; i++)
	{
		charWeight[(unsigned char)inputString[i]]++;
	}
	HuffQueue* queue = NULL;
	InitHuffQueue(&queue);

	for (int i = 0; i <MAX_SZ; i++)
	{
		//对应的字符有权值，创建树结点，添加到树节点队列中
		if (charWeight[i])
		{
			HuffmanNode* treeNode = (HuffmanNode*)malloc(sizeof(HuffmanNode));
			treeNode->data = i;
			treeNode->lchild = treeNode->rchild = NULL;
			AddHuffQueueNode(queue, treeNode, charWeight[i]);
		}
	}
	//根据哈夫曼树创建原理构建哈夫曼树
	//核心就是将权值最小的2个结点，取出作为新创建树结点的孩子结点，新创建树结点的权值为它们之和，然后放回树结点队列
	//一直这样循环进行操作，直到队列中最后剩一个结点，它就是树的根结点。
	while (queue->size != 1)
	{
		HuffQueueNode* node1 = GetHuffQueueNode(queue);
		HuffQueueNode* node2 = GetHuffQueueNode(queue);
		HuffmanNode* treeNode = (HuffmanNode*)malloc(sizeof(HuffmanNode));
		treeNode->data = '\0';
		treeNode->lchild = node1->treeNode;
		treeNode->rchild = node2->treeNode;
		int weightNum = node1->weightNum + node2->weightNum;
		AddHuffQueueNode(queue, treeNode, weightNum);
	}
	return queue->first->treeNode;
}
/*
递归遍历哈夫曼树
depth 树的深度
tree 哈夫曼树
hTable 哈夫曼编码表
encode 字符对应的哈夫曼编码
*/
void traverseHuffTree(HuffmanTable* hTable,HuffmanTree tree,char* encode,int depth)
{
	
	if (NULL == tree->lchild && NULL == tree->rchild)
	{
		HuffmanTableNode* tableNode = (HuffmanTableNode*)malloc(sizeof(HuffmanTableNode));
		tableNode->data = tree->data;
		tableNode->next = NULL;
		encode[depth] = '\0';
		tableNode->encode = (char*)malloc(depth+1);
		strcpy(tableNode->encode, encode);
		if (hTable->front == NULL)
		{
			hTable->front = hTable->tail = tableNode;
		}
		else
		{
			hTable->tail->next = tableNode;
			hTable->tail = tableNode;
		}
	}
	if (NULL != tree->lchild)
	{
		encode[depth] = '0';//左分支代表0
		traverseHuffTree(hTable, tree->lchild, encode, depth+1);
	}

	if (NULL != tree->rchild)
	{
		encode[depth] = '1';//右分支代表1
		traverseHuffTree(hTable, tree->rchild, encode, depth+1);
	}
	return;
}

//根据哈夫曼树生成哈夫曼编码表
HuffmanTable * BuildHuffmanTable(HuffmanTree tree)
{
	HuffmanTable* hTable = (HuffmanTable*)malloc(sizeof(HuffmanTable));
	hTable->front = hTable->tail = NULL;
	char encode[MAX_SZ] = { 0 };
	traverseHuffTree(hTable, tree, encode, 0);
	return hTable;
}

//对用户提供的源字符进行哈夫曼编码
char* encode(HuffmanTable* table,char* src)
{
	char* encode = (char*)calloc(sizeof(char)*MAX_ENCODE,1);
	for (int i = 0; i < src[i]!='\0'; i++)
	{
		char ch = src[i];
		HuffmanTableNode* iterator = table->front;
		while (iterator != NULL)
		{
			if (iterator->data == ch)
			{
				strcat(encode, iterator->encode);
				break;
			}
			iterator = iterator->next;
		}
		if (iterator == NULL)
		{
			printf("哈夫曼编码表中没有字符%c对应的哈夫曼编码！\n",ch);
			return NULL;
		}
	}
	return encode;
}

//根据用户提供的哈夫曼编码进行解码
char* decode(HuffmanTree root,char* encode)
{
	char* decode = (char*)calloc(MAX_SZ, 1);
	HuffmanTree tree = root;
	for (int i = 0; i < encode[i]!='\0'; i++)
	{
		char ch = encode[i];
		if ('0' == ch)//0 往左走
		{
			tree = tree->lchild;
		}
		else//1 往右走
		{
			tree = tree->rchild;
		}
		//走到头，也就是找到相应的 源字符了
		if (tree->lchild == NULL && tree->rchild == NULL)
		{
			strncat(decode, &tree->data, 1);
			//找到字符后，树节点回到根结点，继续解码
			tree = root;
		}
	}
	return decode;
}

//打印哈夫曼编码表
void TraverseHuffmanTable(HuffmanTable* table)
{
	HuffmanTableNode* node = table->front;
	while (node != NULL)
	{
		printf("源字符:%c ->哈夫曼编码:%s\n", node->data, node->encode);
		node = node->next;
	}
}

int main(int argc, char *argv[])
{
	HuffmanTree tree = BuildHuffmanTree("aabbccc");
	HuffmanTable* table = BuildHuffmanTable(tree);
	TraverseHuffmanTable(table);
	char *src = "abc";
	char* dest = "10110101101";
	char* encode_str = encode(table, src);
	char* decode_str = decode(tree, dest);
	printf("原始字符串:%s ->哈夫曼编码:%s\n", src, encode_str);
	printf("哈夫曼编码:%s ->解码为:%s\n", dest, decode_str);
	return 0;
}

图解和运行测试

图解

我们那字符串aabbccc来生成哈夫曼树和哈夫曼编码表。对应的哈夫曼树如下图：

很明显，c字符->哈夫曼编码为0，a字符->哈夫曼编码10，b字符->哈夫曼编码11。

测试代码

int main(int argc, char *argv[])
{
	HuffmanTree tree = BuildHuffmanTree("aabbccc");
	HuffmanTable* table = BuildHuffmanTable(tree);
	TraverseHuffmanTable(table);
	char *src = "abc";
	char* dest = "10110101101";
	char* encode_str = encode(table, src);
	char* decode_str = decode(tree, dest);
	printf("原始字符串:%s ->哈夫曼编码:%s\n", src, encode_str);
	printf("哈夫曼编码:%s ->解码为:%s\n", dest, decode_str);
	return 0;
}

运行结果


重庆李四
关注
专栏目录
哈夫曼编码——用树结构实现的
10-01
用树结构构造出哈弗曼树，然后再求出哈弗曼编码，实现求解的过程
哈夫曼树与哈夫曼编码介绍.zip
04-18
哈夫曼树与哈夫曼编码是数据结构和算法领域中的重要概念，主要应用于数据压缩和效率优化。它们由美国计算机科学家大卫·哈夫曼在20世纪50年代提出，是解决优先队列问题的一种有效方法。在这个压缩包文件中，我们可以...
哈夫曼树及哈夫曼编码的实现
ó
12-28 463
所有数据结构实验中唯一一个值得我记下的，但是感觉自己被指针的指针玩疯了，特此留念~~#include&lt;iostream&gt; #include&lt;cstring&gt; #include&lt;cstdio&gt; using namespace std; const int inf=0x3f3f3f3f; char str[1100]; //电文 char code[1100]; /...
【数据结构】五、树：7.哈夫曼树、哈夫曼编码
最新发布
来csdn只办三件事：开源！开源！还是***开源！
08-07 1352
哈夫曼树（Huffman Tree）：在含有n个带权叶子节点的二叉树中，其中带权路径长度(WPL)最小的二叉树称为哈夫曼树，也称最优二叉树。例如，在上图求WPL的四棵树中，都是4个同样权值的叶子节点，中间两棵树的WPL最小，那么它们两个就是哈夫曼树。。3.哈夫曼树和哈夫曼编码 3.1带权路径长度 3.2哈夫曼树的定义和原理 3.3哈夫曼树的构造 代码实现 3.4特点 3.5哈夫曼编码 压缩比 代码实现 3.6哈夫曼树-C++
哈夫曼树和哈夫曼编码的实现
qq_45735519的博客
07-29 648
对于题目和规则不做赘述，进入正题： 要点： 1.逻辑上哈夫曼树是树结构，但程序的物理结构是数组。 2.树构建好后，规定一下左右是0还是1，然后遍历树的每条路径，即可得到每个数据的编码结果。 代码如下： //哈夫曼编码 typedef struct mesage//在优先级队列中用到的结构体 { mesage(int index = 0, int weight = 0) :index(index), weight(weight) {} int index;//下标，用来标识是哪个叶节点 int w
哈夫曼编码树的C++实现
liuchenjane的博客
11-24 857
哈夫曼编码，参考与《算法导论》 //huffman_another solution #include #include #include #include using namespace std; struct HuffNode{ char key;//关键字 int freq;//出现de频率，即权重 HuffNode* left; HuffNode* right; str
大话数据结构十六：哈夫曼树(最优二叉树)
凤凰涅槃
11-10 189
1. 引子 当前素质教育的背景下，小学的学科成绩都改为了优秀、良好、及格、不及格这样的模糊词语，而不再通报具体的分数。 用代码可以表示如下： if( a &lt; 60 ) System.out.print("不及格"); else if( a &lt; 70 ) System.out.print("及格"); else if( a &lt; 90 ) ...
哈夫曼树和哈夫曼编码的Java实现
11-06
哈夫曼树（Huffman Tree）和哈夫曼编码（Huffman Coding）是数据压缩领域中的基础算法，它们主要用于无损数据压缩。哈夫曼树是一种特殊的二叉树，也称为最优二叉树或最小带权路径长度树，它的构造原则是：频率较高的...
大话数据结构--哈夫曼树
dingxingmei的专栏
11-14 491
刻意练习-理解哈夫曼树构建哈夫曼表C语言
07-24 577
理解哈夫曼树构建哈夫曼表 一、哈夫曼树的作用 哈夫曼树是一个二叉树，是可以将一些字节重新编码 ，而且能够使用最少的空间。所以也叫最优二叉树。 比如这段字符串 damainnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaaaaaaaaaaaaaaaaaaaaaaaaaayikunnnnnnnnnnnnnnnaaaaaaaaaa 这是100个字节。但是如果你构造一个表如下： haffuman_map haffuman_table[]= { {'n',0b0}, {
哈夫曼编码问题（C++ and 贪心 and 指针运用）
ItaLink
05-16 2872
1. 哈夫曼编码问题 问题描述：设需要编码的字符集为{d1, d2, …, dn}，它们出现的频率为{w1, w2, …, wn}，应用哈夫曼树构造最短的不等长编码方案。 提示：哈夫曼树(Huffman Tree),又叫最优二叉树，指的是对于一组具有确定权值的叶子结点的具有最小带权路径长度的二叉树。 哈夫曼树的构造算法：假设有n个权值，则构造出的哈夫曼树有n个叶子结点。n个权值分别设为w1,...
构造哈夫曼树
chengkai730的博客
04-26 106
构造哈夫曼树
哈夫曼树的简单操作-构造哈夫曼树与哈夫曼编码（C语言）
偶然路过的帅小伙z的博客
03-29 898
哈夫曼树的结构定义 构造哈夫曼树 哈夫曼编码的算法实现
哈夫曼树的构造和哈夫曼编码实现详细讲解（含例题详细讲解）
热门推荐
qq_53668991的博客
05-10 1万+
哈夫曼树的构造和哈夫曼编码实现详细讲解（含例题详细讲解），以及例题详解：一个单位有5个部门，每个部门都有一部电话，但是整个单位只有一根外线，当有电话打过来的时候，由转接员转到内线电话，已知各部门使用外线电话的频率为（次/天）：5 16 912 19。利用哈夫曼树算法思想设计内线电话号码，使得接线员拨号次数尽可能少。
假设用于通信的电文由字符集{a,b,c,d,e,f,g}中的字母构成。它们在电文中出现的频度分别为{0.31,0.16,0.10,0.08,0.11,,0.20,0.04},
Aroma
04-30 1万+
1）为这7个字母设计哈夫曼编码； 若设置左0右1，则编码分别如下： a:11 b:101 c:010 d:1001 e:011 f:00 g:1000 2）为这7个字母设计等长编码，至少需要几位二进制数？ 至少需要3位 3）哈夫曼编码比等长编码使电文总长压缩多少？ 压缩14%。利用平均字码长度求解 ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值