weixin_40725706

这个屌丝很懒，什么也没留下！

热门标签

小肥柴慢慢手写数据结构（C篇）（5-5 Huffuman编码）

作者：weixin_40725706 | 2024-04-17 00:09:28

踩

小肥柴慢慢学习数据结构笔记（C篇）（5-5 Huffman编码）

字符	二进制编码
A	0
B	1
C	10
D	11

字符	二进制编码
A	00
B	01
C	10
D	11

还是使用开篇的问题来介绍Huffman编码：给定A、B、C、D四个字母组成的字符串（ABAACDC），要求使用数字0、1对其进行二进制编码。
step1：首先统计各个字符出现的次数，并作为节点，各字符节点拥有一个权重（weight）来表示字符串中该字符出现的次数。
step2：（每次）挑选weight最小的两个节点进行合并，即为这两个节点生成一个父节点，且父节点的weight为两个子节点weight之和。
step3：从剩下的节点（包含还未合并的原始字符节点和生成的父节点）循环执行上述操作，不断地合并最小的两个节点，最终只剩下一个根节点为止。

具体过程如下图所示：
在这里插入图片描述

最后得到编码表：

字符	二进制编码
A	1
B	000
C	001
D	01

编码结果：100011001000001

【观察/性质】

标记所有左枝路径为0，所有右枝路径为1，则可以得到如下编码，称为Huffman编码
按照Huffman编码规则得到的编码结果，一定是在不出现歧义的条件下输出的码长度最短的编码。 ⇒ 后续给出相关学习链接
有关Huffman编码的唯一性，可以绕开数学推导直观地给出证明：
因为所有的叶子结点都是被编码的字符，对树形数据结构来讲，从根节点出发（编码）到叶节点的路径是唯一的，不是吗？ ⇒ 与本章第一节介绍树的基础术语那节对上了！
Huffman编码不是唯一的，因为每次被选中的两个作业节点，总有两种排列方式（且互为镜像）形成新的父节点。
而出现频次高（weight大）的叶子结点排在后面被合并，相反出现频次低（weight小）的叶子结点排在前面被合并，自然而然使得出现频次高的字符的Huffman编码端，从而使得整体编码长度缩短。

关于带权路径长度，WPL

WPL——Weighted Path Length of Tree，简记为 WPL

（1）WPL表示树的所有叶结点的带权路径长度之和。

（2）WPL可用于衡量一颗带权二叉树的优劣。

（3）具体公式为： $WPL=\sum_{i=0}^{ N}w_ip_i$ ，其中 $w_i$ 为权重 $p_i$ 为路径长度，以案例说明
字符A，权重=3，路径长=1；字符B，权重=1，路径长=2…
WPL = 31 + 13 + 22 + 13 = 13
这也是考研/面试/考试经常问到的没有营养的问题。

（4）简单观察这个公式，明显可以看到若能让权重大的字符对应的路径短，则可以减小WPL的值，这与Huffman编码的设计思路是一致的

平均码长于WPL的关系

$L=L(C)=\sum_{i=0}^{ N}p_il_i$ ，其中 $l_i$ 为编码长度， $p_i$ 为编号为 $i$ 的码出现的概率

（1）编码长度 $l_i$ 正好对应WPL中的路径长度（path）

（2）编号为 $i$ 的码出现的概率： $p_i=\frac{w_i}{\sum_{i=0}^{N}w_i}$ ，和WPL中的权重对应起来

（3）其实这个公式本质和WPL一致，仅在定义和变量的命名方式上不同 ⇒ 请看（2）中的定义，秒懂。

至于WPL相关的数学讨论，偏向通信方向和密码学方向（已经超出多数学习数据结构与算法的普通同学的理解了，咱们先挖个坑，有机会慢慢补齐），参考链接 [1]、[2]。

5-18 Huffman编码/解码实现

5-18-1 大致思路

接下来我们会模仿原理部分介绍的Huffman编码/解码操作步骤，尽量降低理解难度。大致思路如下：

（1）编码

step1 统计字符权重
step2 构建Huffman树
step3 对照Huffman树进行编码

需要注意的点：
（1）考虑到编解码的对象是文本字符，可以实用char对应的ASII码作为存储编码列表的索引（index~i），减轻另外实现一套映射算法的额外工作。
（2）为了构建Huffman树（buildHuffTree），用节点数组模拟“森林”（pNode forest[ ]，对应操作addToForest），然后不断从森林中挑选权重最小的两个节点/子树进行合并（getMinNode，mergeNode），在实际挑选时采用每次挑选最小的一个并标记，连续挑选两次的策略，感觉还有改进的空间。
（3）使用递归函数genHuffCode来生成Huffman编码表，借用strcpy和strcat两个API拼接编码字符串。
（4）在判断当前节点是否为字符节点时，可以不做标记，直接判定是否为叶结点即可（isLeaf）。
（5）打印Huffman编码表，采用中序遍历递归实现（printHuffTreeCode）。

（2）解码

step1 拿到之前编码得到的Huffman树
step2 遍历传入的待解码数据（char* / char[]），对照Huffman树找到叶节点，得到一段数据的解码结果，并重置游标（curNode）为Huffman树根节点，循环往复，直到所有数据使用完毕。

5-18-2 编码实现

（1）头文件 HuffmanTree.h

#ifndef _Huffman_Tree_H
#define _Huffman_Tree_H

#define LIST_SIZE 256  					//数据列表长度 
#define FOREST_SIZE (LIST_SIZE * 2 - 1) //构建Huffman树需要产生的森林长度
#define CODE_MAX 512                    //每个字符Huffman编码长度 
#define TEXT_MAX 4028                   //解码文本长度 

struct TreeNode {
    char val;
    int weight;
    char code[CODE_MAX];
    struct TreeNode* left;
    struct TreeNode* right;
};
typedef struct TreeNode* pNode;

char* Encode(char *orgData, int orgLen, pNode root);    //编码，返回编码结果 
char* Decode(char *codeData, int codeLen, pNode root);  //解码，返回解码结果 
void releaseTree(pNode root);                           //递归释放节点 
#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

（2）编码部分
核心代码

char* Encode(char *orgData, int orgLen, pNode root){
	if(orgData == NULL || orgLen == 0){
		printf("编码入参错误!\n");
		return NULL;
	}
	
	if(orgLen == 1){
		printf("仅有一个字符，不用编码!\n");
		return NULL;
	}
	
	int i;
	printf("输入数据：%s\n", orgData);
	//(1)统计权重 
	int freq[LIST_SIZE];
	memset(freq, 0, sizeof(int) * LIST_SIZE);
	for(i=0; i<orgLen; i++){
		freq[orgData[i]]++;
	}
	
	//(2)构建Huffman树
	//C的传参比较繁琐，我不想为了代码看起来漂亮，给buildHuffTree再添加一个引用参数
	//所以采用了类似深拷贝的做法 
	pNode tmpTree = buildHuffTree(freq, LIST_SIZE);
	root->val = tmpTree->val;
	root->weight = tmpTree->weight;
	root->left = tmpTree->left;
	root->right = tmpTree->right;
	free(tmpTree);
	printf("\n字符的霍夫曼编码信息如下：\n");
	printHuffTreeCode(root); 

	//(3)得到编码结果 
	char* ret = doEncode(orgData, orgLen, root);
	
	return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

干活函数

=========================================

static pNode buildHuffTree(int freq[], int codeListlen){
	pNode forest[FOREST_SIZE] = {NULL};
	pNode root = NULL;
	
	int i;
	for(i=0; i<codeListlen; i++){
		if(freq[i]>0)
			addToForest(forest, FOREST_SIZE, creatLeafNode(i, freq[i]));
	}
	
	while(1){
		pNode left = getMinNode(forest, FOREST_SIZE);
		pNode right = getMinNode(forest, FOREST_SIZE);
		
		if(right == NULL) {//仅有一个节点，合并结束 
			root = left;
			break; 
		} else {
			pNode pathNode = mergeNode(left->weight + right->weight);
			pathNode->left = left;
			pathNode->right = right;
			addToForest(forest, FOREST_SIZE, pathNode);
		}
	}
	
	genHuffCode(root);
	return root;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

static void addToForest(pNode forest[], int size, pNode node){
	int i;
	for(i=0; i<size; i++){
		if(forest[i] == NULL){
			forest[i] = node;
			break;
		}
	}
}
1
2
3
4
5
6
7
8
9

static pNode creatLeafNode(int val, int weight){
	pNode node = (pNode)malloc(sizeof(struct TreeNode));
	memset(node, 0, sizeof(struct TreeNode));
	node->val = val;
	node->weight = weight;
	return node;
}
1
2
3
4
5
6
7

static pNode getMinNode(pNode forest[], int size){
	pNode node = NULL;
	
	int min = -1;
	int i;
	for(i=0; i<size; i++){
		if(forest[i] && (min == -1 || forest[min]->weight > forest[i]->weight))
				min = i;				
	}
	
	if(min != -1){
		node = forest[min];
		forest[min] = NULL;
	}
	
	return node;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

static pNode mergeNode(int weight){
	pNode node = (pNode)malloc(sizeof(struct TreeNode));
	memset(node, 0, sizeof(struct TreeNode));
	node->weight = weight;
	return node;
}
1
2
3
4
5
6

static void genHuffCode(pNode curNode){
	if(curNode){
		if(curNode->left){
			strcpy(curNode->left->code, curNode->code);
            strcat(curNode->left->code, "0");
            genHuffCode(curNode->left);
		}
		if(curNode->right){
			strcpy(curNode->right->code, curNode->code);
            strcat(curNode->right->code, "1");
            genHuffCode(curNode->right);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

=============================================================

static int isLeaf(pNode node){
	return node->left == NULL && node->right == NULL;
}

static void inOrder(pNode curNode){
	if(curNode){
		inOrder(curNode->left);
		
		if(isLeaf(curNode))
			printf("字符:%c  权重:%d   编码:%s \n", curNode->val, curNode->weight, curNode->code);
			
		inOrder(curNode->right);
	}
}

static void printHuffTreeCode(pNode node){
	inOrder(node);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

====================================================

static void transHuffTable(pNode HuffTable[], pNode curNode){
	if(curNode){
		if(isLeaf(curNode))
			HuffTable[curNode->val] = curNode;
		
		transHuffTable(HuffTable, curNode->left);
		transHuffTable(HuffTable, curNode->right);
	}
}

static char* doEncode(char *orgData, int orgLen, const pNode root){

	pNode HuffTable[LIST_SIZE] = {NULL};
	transHuffTable(HuffTable, root);
	
	//这里写的不好，为了节省空间采取了一个笨办法 
	int i;
	int totalSize = 0;
	for(i=0; i<orgLen; i++)
		totalSize += strlen(HuffTable[orgData[i]]->code);
	printf("\n霍夫曼编码长度:%d", totalSize);
	
	char* HuffCode = (char *)malloc(sizeof(char) * (totalSize+1));
	memset(HuffCode, 0, totalSize+1);
	for(i=0; i<orgLen; i++)
		strcat(HuffCode, HuffTable[orgData[i]]->code);
	
	return HuffCode;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

5-18-3 解码实现

char* Decode(char *codeData, int codeLen, pNode root){
	if(codeData == NULL || codeLen == 0 || root == NULL){
		printf("\n解码入参错误!\n");
		return NULL;
	}
	
	if(codeLen == 1){
		printf("仅有一个字符，不用解码!\n");
		return NULL;
	}
	
	//此处也是一个笨办法，应该去看论文估计一下长度 
	char* text = (char *)malloc(sizeof(char) * (TEXT_MAX));
	memset(text, 0, TEXT_MAX);
	int i,j;
	pNode curNode = root;
	//按照之前思路模拟实现，虽然贴近人的自然思维，但是效率不高 
	for(i=0, j=0; i<codeLen; i++){
		curNode = codeData[i] == '0' ? curNode->left : curNode->right;
		if(isLeaf(curNode)){
			text[j++] = curNode->val;
			curNode = root;
		}
	}
	return text;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

=======================================================
完整的 HuffmanTree.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "HuffmanTree.h"


static pNode getMinNode(pNode forest[], int size){
	pNode node = NULL;
	
	int min = -1;
	int i;
	for(i=0; i<size; i++){
		if(forest[i] && (min == -1 || forest[min]->weight > forest[i]->weight))
				min = i;				
	}
	
	if(min != -1){
		node = forest[min];
		forest[min] = NULL;
	}
	
	return node;
}

static pNode mergeNode(int weight){
	pNode node = (pNode)malloc(sizeof(struct TreeNode));
	memset(node, 0, sizeof(struct TreeNode));
	node->weight = weight;
	return node;
}

static pNode creatLeafNode(int val, int weight){
	pNode node = (pNode)malloc(sizeof(struct TreeNode));
	memset(node, 0, sizeof(struct TreeNode));
	node->val = val;
	node->weight = weight;
	return node;
}

static void addToForest(pNode forest[], int size, pNode node){
	int i;
	for(i=0; i<size; i++){
		if(forest[i] == NULL){
			forest[i] = node;
			break;
		}
	}
}

static void genHuffCode(pNode curNode){
	if(curNode){
		if(curNode->left){
			strcpy(curNode->left->code, curNode->code);
            strcat(curNode->left->code, "0");
            genHuffCode(curNode->left);
		}
		if(curNode->right){
			strcpy(curNode->right->code, curNode->code);
            strcat(curNode->right->code, "1");
            genHuffCode(curNode->right);
		}
	}
}

static pNode buildHuffTree(int freq[], int codeListlen){
	pNode forest[FOREST_SIZE] = {NULL};
	pNode root = NULL;
	
	int i;
	for(i=0; i<codeListlen; i++){
		if(freq[i]>0)
			addToForest(forest, FOREST_SIZE, creatLeafNode(i, freq[i]));
	}
	
	while(1){
		pNode left = getMinNode(forest, FOREST_SIZE);
		pNode right = getMinNode(forest, FOREST_SIZE);
		
		if(right == NULL) {//仅有一个节点，合并结束 
			root = left;
			break; 
		} else {
			pNode pathNode = mergeNode(left->weight + right->weight);
			pathNode->left = left;
			pathNode->right = right;
			addToForest(forest, FOREST_SIZE, pathNode);
		}
	}
	
	genHuffCode(root);
	return root;
}

static int isLeaf(pNode node){
	return node->left == NULL && node->right == NULL;
}

static void inOrder(pNode curNode){
	if(curNode){
		inOrder(curNode->left);
		
		if(isLeaf(curNode))
			printf("字符:%c  权重:%d   编码:%s \n", curNode->val, curNode->weight, curNode->code);
			
		inOrder(curNode->right);
	}
}

static void printHuffTreeCode(pNode node){
	inOrder(node);
}

static void transHuffTable(pNode HuffTable[], pNode curNode){
	if(curNode){
		if(isLeaf(curNode))
			HuffTable[curNode->val] = curNode;
		
		transHuffTable(HuffTable, curNode->left);
		transHuffTable(HuffTable, curNode->right);
	}
}

static char* doEncode(char *orgData, int orgLen, const pNode root){

	pNode HuffTable[LIST_SIZE] = {NULL};
	transHuffTable(HuffTable, root);
	
	//这里写的不好，为了节省空间采取了一个笨办法 
	int i;
	int totalSize = 0;
	for(i=0; i<orgLen; i++)
		totalSize += strlen(HuffTable[orgData[i]]->code);
	printf("\n霍夫曼编码长度:%d", totalSize);
	
	char* HuffCode = (char *)malloc(sizeof(char) * (totalSize+1));
	memset(HuffCode, 0, totalSize+1);
	for(i=0; i<orgLen; i++)
		strcat(HuffCode, HuffTable[orgData[i]]->code);
	
	return HuffCode;
}

static void doReleaseTree(pNode curNode){
	if(curNode){
		doReleaseTree(curNode->left);
		doReleaseTree(curNode->right);
	}
}

char* Encode(char *orgData, int orgLen, pNode root){
	if(orgData == NULL || orgLen == 0){
		printf("编码入参错误!\n");
		return NULL;
	}
	
	if(orgLen == 1){
		printf("仅有一个字符，不用编码!\n");
		return NULL;
	}
	
	int i;
	printf("输入数据：%s\n", orgData);
	//(1)统计权重 
	int freq[LIST_SIZE];
	memset(freq, 0, sizeof(int) * LIST_SIZE);
	for(i=0; i<orgLen; i++){
		freq[orgData[i]]++;
	}
	
	//(2)构建Huffman树
	//C的传参比较繁琐，我不想为了代码看起来漂亮，给buildHuffTree再添加一个引用参数
	//所以采用了类似深拷贝的做法 
	pNode tmpTree = buildHuffTree(freq, LIST_SIZE);
	root->val = tmpTree->val;
	root->weight = tmpTree->weight;
	root->left = tmpTree->left;
	root->right = tmpTree->right;
	free(tmpTree);
	printf("\n字符的霍夫曼编码信息如下：\n");
	printHuffTreeCode(root); 

	//(3)得到编码结果 
	char* ret = doEncode(orgData, orgLen, root);
	
	return ret;
}

char* Decode(char *codeData, int codeLen, pNode root){
	if(codeData == NULL || codeLen == 0 || root == NULL){
		printf("\n解码入参错误!\n");
		return NULL;
	}
	
	if(codeLen == 1){
		printf("仅有一个字符，不用解码!\n");
		return NULL;
	}
	
	//此处也是一个笨办法，应该去看论文估计一下长度 
	char* text = (char *)malloc(sizeof(char) * (TEXT_MAX));
	memset(text, 0, TEXT_MAX);
	int i,j;
	pNode curNode = root;
	//按照之前思路模拟实现，虽然贴近人的自然思维，但是效率不高 
	for(i=0, j=0; i<codeLen; i++){
		curNode = codeData[i] == '0' ? curNode->left : curNode->right;
		if(isLeaf(curNode)){
			text[j++] = curNode->val;
			curNode = root;
		}
	}
	return text;
}



void releaseTree(pNode root){
	doReleaseTree(root);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219

5-18-4 测试

（1）测试代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "HuffmanTree.h"

int main(int argc, char *argv[]) {
	char test1[] = {'A', 'B', 'A', 'A', 'C', 'D', 'C'}; //ABAACDC
	struct TreeNode huffTree1;
	char* huffEncode1 = Encode(test1, strlen(test1), &huffTree1);
	printf("\n\n霍夫曼编码结果: %s", huffEncode1);
	
	char* huffDecode1 = Decode(huffEncode1, strlen(huffEncode1), &huffTree1);
	printf("\n\n霍夫曼译码结果: %s", huffDecode1);
	
	printf("\n=======================================\n");
	
	//write file name
	char test2[] = {'w', 'r', 'i', 't', 'e', ' ', 'f', 'i', 'l', 'e', ' ', 'n', 'a', 'm', 'e'}; 
	struct TreeNode huffTree2;
	char* huffEncode2 = Encode(test2, strlen(test2), &huffTree2);
	printf("\n\n霍夫曼编码结果: %s", huffEncode2);
	
	char* huffDecode2 = Decode(huffEncode2, strlen(huffEncode2), &huffTree2); 
	printf("\n\n霍夫曼译码结果: %s", huffDecode2);
	printf("\n=======================================\n");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

（2）测试结果
在这里插入图片描述

【遗憾】
（1）正如前面讨论的，这个程序是参考[3]修修补补完成的，当然也可以参考[3]和[4]去做成完整版的利用Huffman编码对文件进行压缩和解压的经典案例（重点在于能让大家观察到压缩/解压的操作的时间和空间效率，真正做到学以致用），
（2）对Huffman编解码的对应数学理论我们仅了解到皮毛，因此在具体编码中还有很多申请/释放空间的处理不够智慧，应该抽空研究一下真实开源案例，看看学习别人的实现手法。
（3）黑皮书里给出了相关论文，见[13]，[14]，[15]，[16]。

以上问题，有空我们补一个帖子试试看。

【注】另外，很多Huffman教学贴中，编码实现阶段，为节点定义了一个指向父节点的指针，也不失为一种常见的解决方案，参看[4]

// 定义哈夫曼树节点
typedef struct {
	int weight;
	int parent;
	int l_child;
	int r_child;
	char data;
} HTNode, * HuffmanTree;
typedef char** HuffmanCode;
1
2
3
4
5
6
7
8
9

5-19 实际案例

（1）硬件编解码，参考 [6]，[7]，[8]
（2）其他参考[9]，[10]，[11]，[12]

多媒体方向的水很深，看情况慢慢研究吧。

总结

（1）Huffman编码的应用非常广泛。
（2）Huffman编码是一种变长的编码，可配合类似树状的数据结构存储编码表。
（3）对于森林这个概念，我们没有介绍，直接在实践中学习。

【吐槽】C的传值解决方法不太优雅。

参考文献

[1] 信息与编码系列（一）源码
[2] 信息与编码系列（二）最优码——Huffman码
[3] C语言实现Huffman的编码和解码 ==> 值得看，树形结构的打印不错，对文件的编解码也挺好
[4] C语言课程设计-文件的哈夫曼编码与解码 ==> 对时间和空间的统计展示值得借鉴
[5] 哈夫曼编码详细证明步骤
[6] 硬件huffman解码器（一）：huffman编码原理
[7] 硬件huffman解码器（二）：串行解码及其优化
[8] 硬件huffman解码器（三）-并行解码
[9] 语音处理：霍夫曼编码算法原理分析 ==> 提到了Jpeg
[10] MP3 和 AAC 中huffman解码原理，优化设计与参考代码中实现
[11] Android 性能优化 03—Bitmap优化02（huffman压缩）
[12] Android图片压缩原理分析（三）—— 哈夫曼压缩讲解 ==> Android Skia 图像引擎
[13] D. A. Huffman,“AMethod for the Construction of Minimum Redundancy Codes,” Proceedings of the IRE, 40 (1952),1098-1101. ==> 开山鼻祖
[14] D.E. Knuth, “Dynamic Huffman Coding,”Journal of Algorithms, 6 (1985),163-180.
[15] L.L. Larmore, “Height-Restricted Optimal Binary Trees,”SIAM Journal on Computing, 16 (1987),1115-1123.
[16] L. L. Larmoreand D.S. Hirschberg,“A Fast Algorithm for Optimal Length-Limited Huffman Codes,”Journal of the ACM, 37 (1990), 464-473.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/437164

小肥柴慢慢手写数据结构（C篇）（5-5 Huffuman编码）

小肥柴慢慢学习数据结构笔记（C篇）（5-5 Huffman编码）

目录

5-16 编码案例

5-17 Huffman编码原理

5-18 Huffman编码/解码实现

5-18-1 大致思路

5-18-2 编码实现

5-18-3 解码实现

5-18-4 测试

5-19 实际案例

总结

参考文献