从零开始学数据结构系列之第三章《哈夫曼编码构造及代码》

文章目录

哈夫曼编码基本概念
哈夫曼编码方法
- 两个特点
总代码
往期回顾

哈夫曼编码基本概念

哈夫曼编码，又称为 Huffman Coding

是一种可变长编码（ VLC, variable length coding)）方式，比起定长编码的 ASCII 编码来说，哈夫曼编码能节省很多的空间，因为每一个字符出现的频率不是一致的；

是一种用于无损数据压缩的熵编码算法，通常用于压缩重复率比较高的字符数据。

如果我们通过转换成ASCII码对应的二进制数据将字符串 BCAADDDCCACACAC 通过二进制编码进行传输，那么一个字符传输的二进制位数为 8bits，那么总共需要 120 个二进制位；而如果使用哈夫曼编码，该串字符可压缩至 28位。

在这里插入图片描述

哈夫曼编码方法

哈夫曼编码首先会使用字符的频率创建一棵树，然后通过这个树的结构为每个字符生成一个特定的编码，出现频率高的字符使用较短的编码，出现频率低的则使用较长的编码，这样就会使编码之后的字符串平均长度降低，从而达到数据无损压缩的目的。
在这里插入图片描述
2. 按照字符出现的频率进行排序，组成一个队列 Q 出现频率最低的在前面，出现频率高的在后面。

3. 把这些字符作为叶子节点开始构建一颗哈夫曼树
哈夫曼树又称为最优二叉树，是一种带权路径长度最短的二叉树。

（1）首先创建一个空节点 z，将最小频率的字符分配给 z 的左侧，并将频率排在第二位的分配给 z 的右侧，然后将 z 赋值为两个字符频率的和；然后从队列 Q 中删除 B 和 D，并将它们的和添加到队列中，上图中 * 表示的位置。
在这里插入图片描述
（2）紧接着，重新创建一个空的节点 z，并将 4 作为左侧的节点，频率为 5 的 A 作为右侧的节点，4 与 5 的和作为父节点，并把这个和按序加入到队列中，再根据频率从小到大构建树结构（小的在左）。

3）
继续按照之前的思路构建树，直到所有的字符都出现在树的节点中，哈弗曼树构建完成。

节点的带权路径长度为从根节点到该节点的路径长度与节点权值的乘积。

该二叉树的带权路径长度 WPL = 6 * 1 + 5 * 2 + 3 * 3 + 1 * 3 = 28。

在这里插入图片描述
4. 对字符进行编码：

哈夫曼树构建完成，下面我们要对各个字母进行编码，编码原则是：对于每个非叶子节点，将 0 分配给连接线的左侧，1 分配给连接线的右侧，最终得到字符的编码就是从根节点开始，到该节点的路径上的 0 1 序列组合。
在这里插入图片描述

在没有经过哈夫曼编码之前，字符串“BCAADDDCCACACAC”的二进制为：

10000100100001101000001010000010100010001000100010001000100001101000011010000010100001101000001010000110100000101000011

也就是占了 120 比特；

编码之后为：

1000111110110110100110110110

占了 28 比特。

再看我们上面的内容
在这里插入图片描述
或者：

两个特点

带权路径长度WPL最短且唯一；

编码互不为前缀（一个编码不是另一个编码的开头）。

为什么通过哈夫曼编码后得到的二进制码不会有前缀的问题呢？
这是因为在哈夫曼树中，每个字母对应的节点都是叶子节点，而他们对应的二进制码是由根节点到各自节点的路径所决定的，正因为是叶子节点，每个节点的路径不可能和其他节点有前缀的关系。

为什么通过哈夫曼编码获得的二进制码短呢？
因为哈夫曼树是带权路径长度最短的树，权值较大的节点离根节点较近。而带权路径长度是指：树中所有的叶子节点的权值乘上其到根节点的路径长度，这与最终的哈夫曼编码总长度成正比关系的。

总代码

#include <stdio.h>
#include <stdlib.h>
    
typedef struct TreeNode 
{
    int weight;
    int parent;
    int lchild;
    int rchild;
}TreeNode;

typedef struct HFTree 
{
    TreeNode* data;
    int length;
}HFTree;

/*
* 开辟空间，同时赋予初值，这边左右子树未塞入值时，初始值为-1
* 同时将权值注入
*/

HFTree* initTree(int* weight,  int length) 
{
	int i=0;
	HFTree *T = (HFTree*)malloc(sizeof(HFTree));
	T->data = (TreeNode*)malloc(sizeof(TreeNode) * (length * 2 - 1));
	T->length = length;
	for(i=0;i<length;i++)
	{
		T->data[i].parent = 0;
		T->data[i].lchild = -1;
		T->data[i].rchild = -1;
		T->data[i].weight = weight[i];
	}
	return T;
}

/*
* 这里的min，second_min均为设置的初值，同时循环寻找最小值并更新该值
* 同时传递两个int 类型的数值，需要开辟空间过去
*/

int* selectMin(HFTree* T) 
{
	int i=0;
	int min = 100000;
	int second_min = 100000;

	int flag_first=0;
	int flag_second =0;

	int *address = (int*)malloc(sizeof(int) * 2);
	
	for(i=0;i<T->length;i++)
	{
		if(T->data[i].weight<min && T->data[i].parent == 0)
		{
			min=T->data[i].weight;
			flag_first=i;
		}
	}

	for(i=0;i<T->length;i++)
	{
		if(T->data[i].weight<second_min && T->data[i].parent == 0 && i !=flag_first)
		{
			second_min=T->data[i].weight;
			flag_second=i;
		}
	}
	address[0] = flag_first;
	address[1] = flag_second;
	return address;
}

/*
* length = T->length * 2 - 1;这里的初始值是最终开辟的整个空间大小，因为后续会新增父节点
* 左右子树赋予初值，这里顺序可以可以颠倒，并不影响最终结果
* 同时更新并初始化新值，T -> data[i].parent = 0;如果没有这个，selectMin函数并不会将新增值列入判断范围
*/

void createHFTree(HFTree* T) 
{
	int i=0;

	int length = T->length * 2 - 1;
	int *receive=NULL;

	for(i=T->length;i<length;i++)
	{
		receive=selectMin(T);
		T->data[i].lchild = receive[0];
		T->data[i].rchild = receive[1];
		T->data[i].weight = T->data[receive[0]].weight + T->data[receive[1]].weight;
		T -> data[i].parent = 0;
		T -> data[receive[0]].parent = i;
		T -> data[receive[1]].parent = i;
		T->length++;
	}

}

void preOrder(HFTree* T, int index) 
{
	if (index != -1) 
	{
        printf("%d ", T -> data[index].weight);
        preOrder(T, T -> data[index].lchild);
        preOrder(T, T -> data[index].rchild);
    }

}

int main() 
{
    int weight[] = {1,2,3,4};
    HFTree* T = initTree(weight, sizeof(weight)/sizeof(int));
    createHFTree(T);
    preOrder(T, T -> length - 1);
    printf("\n");
    return 0;
}

在这里插入图片描述

往期回顾