哈夫曼算法的实现及应用
哈夫曼编码的应用实例
哈夫曼编码的应用实例引言哈夫曼编码是一种常用的数据压缩算法，它通过将出现频率较高的字符用较短的编码表示，从而实现对数据的高效压缩。
本文将通过几个实际应用实例来介绍哈夫曼编码的工作原理和应用场景。
什么是哈夫曼编码哈夫曼编码是由David A. Huffman于1952年提出的一种数据压缩算法。
它通过统计字符的出现频率，然后构建一棵二叉树，将频率较高的字符放在树的较低层，频率较低的字符放在树的较高层，从而实现对数据的压缩。
哈夫曼编码的原理1.统计字符的出现频率：首先需要统计待压缩数据中每个字符的出现频率。
2.构建哈夫曼树：根据字符的出现频率构建一棵哈夫曼树。
构建树的过程中，频率较低的字符被放在树的较高层，频率较高的字符被放在树的较低层。
3.生成哈夫曼编码：从根节点开始，沿着左子树走为0，沿着右子树走为1，将每个字符对应的编码记录下来。
4.进行编码压缩：将待压缩数据中的每个字符用其对应的哈夫曼编码替代。
5.进行解码还原：通过哈夫曼树和编码，将压缩后的数据解码还原为原始数据。
哈夫曼编码的应用实例文本文件压缩文本文件通常包含大量的字符，而且某些字符的出现频率较高。
通过使用哈夫曼编码，可以将出现频率较高的字符用较短的编码表示，从而实现对文本文件的高效压缩。
1.统计字符的出现频率：首先需要对待压缩的文本文件进行字符频率统计，得到每个字符的出现频率。
2.构建哈夫曼树：根据字符的出现频率构建一棵哈夫曼树。
3.生成哈夫曼编码：根据哈夫曼树，为每个字符生成对应的哈夫曼编码。
4.进行编码压缩：将待压缩的文本文件中的每个字符用其对应的哈夫曼编码替代。
5.进行解码还原：通过哈夫曼树和编码，将压缩后的数据解码还原为原始文本文件。
图像压缩图像文件通常包含大量的像素点，每个像素点包含多个颜色信息。
通过使用哈夫曼编码，可以将出现频率较高的颜色用较短的编码表示，从而实现对图像文件的高效压缩。
1.统计颜色的出现频率：首先需要对待压缩的图像文件进行颜色频率统计，得到每个颜色的出现频率。
数据压缩算法中的哈夫曼编码原理及应用
数据压缩算法中的哈夫曼编码原理及应用哈夫曼编码是一种常用的数据压缩算法，它的原理是通过对待压缩的数据进行频率统计，将频率较高的字符赋予较短的编码，频率较低的字符赋予较长的编码，从而实现对数据的高效压缩。
哈夫曼编码的应用广泛，包括文件压缩、通信传输、数据存储等方面。
哈夫曼编码的原理可以简单描述为以下几个步骤：1.频率统计：将待压缩的数据进行频率统计，统计每个字符出现的次数，得到字符频率表。
2.构建哈夫曼树：根据字符频率表，构建哈夫曼树。
哈夫曼树是一种特殊的二叉树，其中每个叶子节点对应着一个字符，其路径长度代表该字符的编码长度。
3.生成编码：从哈夫曼树的根节点开始，对每个叶子节点进行编码生成。
从根节点到叶子节点的路径上的边分为0和1，路径上的0表示向左走，1表示向右走，从而得到每个字符的哈夫曼编码。
4.压缩数据：将原始数据按照生成的哈夫曼编码进行压缩，将每个字符替换为对应的哈夫曼编码。
5.解压数据：根据压缩后的数据和哈夫曼树，进行解压还原。
从根节点开始，按照压缩数据的0和1进行路径遍历，当遇到叶子节点时，即可找到对应的字符。
哈夫曼编码的应用非常广泛，下面介绍几个常见的应用领域：1.文件压缩：哈夫曼编码在文件压缩中有着重要的应用。
通过统计文件中每个字符的出现频率，构建哈夫曼树，并生成对应的哈夫曼编码，将字符替换为哈夫曼编码后，可以大大减少文件的存储空间。
当文件中存在一些频率较高的字符时，哈夫曼编码的效果尤为显著。
2.图片压缩：在图片压缩中，哈夫曼编码通常用于无损压缩。
将图像中的像素点表示为字符，通过统计每个字符出现的频率，构建哈夫曼树，并生成对应的哈夫曼编码。
将像素点替换为哈夫曼编码后，图像的存储空间可以大大减小，同时保证了图像的质量不受损失。
3.音频压缩：在音频压缩中，哈夫曼编码常用于有损压缩，例如MP3格式的音频文件。
在有损压缩中，通过对音频数据进行量化和编码，可以减小文件的大小，从而方便传输和存储。
哈夫曼编码算法实现
哈夫曼编码（Huffman Coding）是一种常见的数据压缩算法，它通过构建哈夫曼树（Huffman Tree）来实现。
以下是一个简单的哈夫曼编码算法的实现示例，使用Python 语言：pythonCopy codeimport heapqfrom collections import defaultdictclass HuffmanNode:def __init__(self, char, frequency):self.char = charself.frequency = frequencyself.left = Noneself.right = Nonedef __lt__(self, other):return self.frequency < other.frequencydef build_huffman_tree(data):frequency = defaultdict(int)for char in data:frequency[char] += 1priority_queue = [HuffmanNode(char, freq) for char, freq in frequency.items()]heapq.heapify(priority_queue)while len(priority_queue) > 1:node1 = heapq.heappop(priority_queue)node2 = heapq.heappop(priority_queue)merged_node = HuffmanNode(None, node1.frequency + node2.frequency)merged_node.left = node1merged_node.right = node2heapq.heappush(priority_queue, merged_node)return priority_queue[0]def build_huffman_codes(root, current_code="", codes={}):if root:if root.char is not None:codes[root.char] = current_codebuild_huffman_codes(root.left, current_code + "0", codes)build_huffman_codes(root.right, current_code + "1", codes)return codesdef huffman_encoding(data):if not data:return None, Noneroot = build_huffman_tree(data)codes = build_huffman_codes(root)encoded_data = "".join([codes[char] for char in data])return encoded_data, rootdef huffman_decoding(encoded_data, root):if not encoded_data or not root:return Nonecurrent_node = rootdecoded_data = ""for bit in encoded_data:if bit == "0":current_node = current_node.leftelse:current_node = current_node.rightif current_node.char is not None:decoded_data += current_node.charcurrent_node = rootreturn decoded_data# 示例data = "abracadabra"encoded_data, tree_root = huffman_encoding(data) decoded_data = huffman_decoding(encoded_data, tree_root)print("Original data:", data)print("Encoded data:", encoded_data)print("Decoded data:", decoded_data)。
哈夫曼树及哈夫曼编码的算法实现c语言
哈夫曼树及哈夫曼编码的算法实现c语言1.引言1.1 概述哈夫曼树及哈夫曼编码是数据压缩和编码中常用的重要算法。
哈夫曼树由大卫·哈夫曼于1952年提出，用于根据字符出现的频率构建一种最优的前缀编码方式。
而哈夫曼编码则是根据哈夫曼树构建的编码表将字符进行编码的过程。
在现代通信和计算机领域，数据传输和存储中往往需要大量的空间。
为了有效利用有限的资源，减少数据的存储和传输成本，数据压缩成为一个重要的技术。
而哈夫曼树及哈夫曼编码正是数据压缩中常用的技术之一。
哈夫曼树的概念及原理是基于字符的频率和概率进行构建的。
在哈夫曼树中，字符出现频率越高的节点越接近根节点，出现频率越低的节点离根节点越远。
这种构建方式保证了哈夫曼树的最优性，即最小化编码的总长度。
哈夫曼编码的算法实现是根据哈夫曼树构建的编码表进行的。
编码表中，每个字符都与一段二进制编码相对应。
在进行数据压缩和解压缩时，通过查表的方式将字符转化为相应的二进制编码，或将二进制编码解析为原始字符。
本文旨在介绍哈夫曼树及哈夫曼编码的概念和原理，并通过C语言实现算法。
通过深入理解哈夫曼树及哈夫曼编码的实现过程，可以更好地理解数据压缩和编码的原理，为后续的研究和应用提供基础。
接下来，我们将首先介绍哈夫曼树的概念和原理，然后详细讲解哈夫曼编码的算法实现。
最后，我们将总结哈夫曼树及哈夫曼编码的重要性，并提出对哈夫曼树和哈夫曼编码进一步研究的方向。
让我们一起深入探索哈夫曼树及哈夫曼编码的奥秘吧！1.2 文章结构文章结构部分的内容可以包括以下内容：文章结构部分主要介绍了本文的组织结构和各个章节的内容概述，以帮助读者更好地理解全文的逻辑结构和内容安排。
首先，本文包括引言、正文和结论三个部分。
引言部分主要对哈夫曼树及哈夫曼编码的算法实现进行了概述，包括相关的概念、原理和目的。
正文部分则深入介绍了哈夫曼树的概念和原理，以及哈夫曼编码的算法实现。
最后，结论部分对本文的主要内容进行了总结，并提出了对哈夫曼树和哈夫曼编码的进一步研究方向。
哈夫曼算法的理解及原理分析算法实现构造哈夫曼树的算法
哈夫曼算法的理解及原理分析算法实现构造哈夫曼树的算法哈夫曼算法（Huffman Algorithm）是一种贪心算法，用于构建最优二叉树（也称为哈夫曼树或者最优前缀编码树），主要用于数据压缩和编码。
它通过统计字符出现的频率来构建一个编码表，将较频繁出现的字符用较短的编码表示，从而减少存储空间和传输带宽。
原理分析：1.统计字符出现的频率：遍历待编码的字符串，统计每个字符出现的次数。
2.构建哈夫曼树：根据字符频率构建二叉树，频率越高的字符位置越靠近根节点，频率越低的字符位置越远离根节点。
构建哈夫曼树的通常做法是使用最小堆来存储频率，并反复合并堆中最小的两个节点，直到堆中只剩一个节点，即根节点。
3.生成编码表：从根节点开始，沿着左子树为0，右子树为1的路径将所有叶子节点的编码存储在一个编码表中。
算法实现：下面是一个简单的Python实现示例：```pythonclass Node:def __init__(self, char, freq):self.char = charself.freq = freqself.left = Noneself.right = Nonedef build_huffman_tree(text):#统计字符频率freq_dict = {}for char in text:if char in freq_dict:freq_dict[char] += 1else:freq_dict[char] = 1#构建最小堆heap = []for char, freq in freq_dict.items(: node = Node(char, freq)heap.append(node)heap.sort(key=lambda x: x.freq)#构建哈夫曼树while len(heap) > 1:left = heap.pop(0)right = heap.pop(0)parent = Node(None, left.freq + right.freq) parent.left = leftparent.right = rightheap.append(parent)heap.sort(key=lambda x: x.freq)root = heap[0]#生成编码表code_table = {}generate_code(root, "", code_table)return code_tabledef generate_code(node, code, code_table):if node.char:code_table[node.char] = codereturngenerate_code(node.left, code + "0", code_table) generate_code(node.right, code + "1", code_table) ```构造哈夫曼树的算法：上述的 `build_huffman_tree` 函数通过统计频率构建了最小堆`heap`，然后不断地合并最小的两个节点，直到堆中只剩下一个节点，即哈夫曼树的根节点。
哈夫曼树编码实验报告
哈夫曼树编码实验报告哈夫曼树编码实验报告引言：哈夫曼树编码是一种常用的数据压缩算法，通过对数据进行编码和解码，可以有效地减小数据的存储空间。
本次实验旨在探究哈夫曼树编码的原理和应用，并通过实际案例验证其有效性。
一、哈夫曼树编码原理哈夫曼树编码是一种变长编码方式，根据字符出现的频率来确定不同字符的编码长度。
频率较高的字符编码较短，频率较低的字符编码较长，以达到最佳的数据压缩效果。
1.1 字符频率统计首先，需要对待编码的数据进行字符频率统计。
通过扫描数据，记录每个字符出现的次数，得到字符频率。
1.2 构建哈夫曼树根据字符频率构建哈夫曼树，频率较低的字符作为叶子节点，频率较高的字符作为父节点。
构建哈夫曼树的过程中，需要使用最小堆来维护节点的顺序。
1.3 生成编码表通过遍历哈夫曼树，从根节点到每个叶子节点的路径上的左右分支分别赋予0和1，生成对应的编码表。
1.4 数据编码根据生成的编码表，将待编码的数据进行替换，将每个字符替换为对应的编码。
编码后的数据长度通常会减小，实现了数据的压缩。
1.5 数据解码利用生成的编码表，将编码后的数据进行解码，恢复原始数据。
二、实验过程与结果为了验证哈夫曼树编码的有效性，我们选择了一段文本作为实验数据，并进行了以下步骤：2.1 字符频率统计通过扫描文本，统计每个字符出现的频率。
我们得到了一个字符频率表，其中包含了文本中出现的字符及其对应的频率。
2.2 构建哈夫曼树根据字符频率表，我们使用最小堆构建了哈夫曼树。
频率较低的字符作为叶子节点，频率较高的字符作为父节点。
最终得到了一棵哈夫曼树。
2.3 生成编码表通过遍历哈夫曼树，我们生成了对应的编码表。
编码表中包含了每个字符的编码，用0和1表示。
2.4 数据编码将待编码的文本数据进行替换，将每个字符替换为对应的编码。
编码后的数据长度明显减小，实现了数据的压缩。
2.5 数据解码利用生成的编码表，将编码后的数据进行解码，恢复原始文本数据。
哈夫曼编码算法详解
哈夫曼编码算法详解在计算机科学中，哈夫曼编码是一种压缩算法，也叫做霍夫曼编码，是由霍夫曼(Huffman)在1952年首创的。
霍夫曼编码是一种无损压缩算法，可以对文本文件、音频文件、图像文件等各种类型的文件进行压缩。
1. 哈夫曼编码的原理哈夫曼编码是基于频率统计的思想，通过统计每个字符在文件中出现的频率，选择出现频率最高的字符，将其映射为一组比特位，出现频率较低的字符则映射为比高的比特位，从而实现对文件的压缩。
通过哈夫曼编码，可以将文件压缩到原始大小的一半甚至更小。
2. 哈夫曼编码的实现哈夫曼编码的实现需要进行几个步骤：2.1 统计字符的出现频率从文件中读取字符，统计每个字符在文件中出现的次数，可以使用一个数组或字典来保存每个字符的出现次数。
对于英文文本来说，出现频率最高的字符是空格，其次是字母“e”。
2.2 构建哈夫曼树将所有的字符按照出现频率从小到大排序，选出出现频率最小的两个字符作为左右子节点，其父节点的出现频率为左右子节点出现频率之和。
重复这个过程，直到节点数为1，这样就得到了一棵哈夫曼树。
2.3 生成哈夫曼编码从哈夫曼树的根节点开始，遍历所有的节点，将左子节点标记为0，将右子节点标记为1，将所有的叶子节点的字符和对应的哈夫曼编码保存到一个字典中。
最终得到了每个字符对应的哈夫曼编码。
2.4 进行压缩将文件中每个字符替换为对应的哈夫曼编码，然后将所有的哈夫曼编码拼接成一个二进制数，在最后不足8位的位置补零，将其存储到文件中。
这样就完成了文件的压缩。
3. 哈夫曼编码的优点哈夫曼编码具有以下优点：3.1 压缩率高由于哈夫曼编码是根据不同字符的出现频率来进行编码的，出现频率高的字符用较短的编码表示，出现频率低的字符用较长的编码表示，能够最大限度地减少文件的大小，从而达到高的压缩率。
3.2 唯一解哈夫曼编码是通过构建哈夫曼树来得到每个字符对应的编码，哈夫曼树的构建是唯一的，因此哈夫曼编码也是唯一的。
哈夫曼编码算法
哈夫曼编码算法哈夫曼编码算法是一种基于编码理论的高效数据压缩算法。
它是由美国数学家大卫·哈夫曼于1952年提出的，被广泛应用于数据压缩、图像处理、音频处理、通信传输等领域。
哈夫曼编码算法的核心思想是利用字符出现的频率来设计一种最优的编码方式，使得压缩后的数据长度最短。
具体来说，它将出现频率较高的字符用较短的编码表示，而将出现频率较低的字符用较长的编码表示，从而实现了数据的压缩。
在哈夫曼编码算法中，首先需要统计待压缩数据中各个字符出现的频率，并将其构建成一棵二叉树。
在构建二叉树的过程中，每个字符都被看作是一个叶子节点，其出现频率越高，其在二叉树中的位置越靠近根节点。
构建完二叉树后，再对每个叶子节点进行编码，将其路径上的0和1分别表示为0和1的编码序列，这样就得到了每个字符的哈夫曼编码。
对于任意一段待压缩数据，可以根据字符的哈夫曼编码将其转换为一串由0和1组成的二进制序列。
由于哈夫曼编码是一种前缀编码，即任何一个字符的编码序列都不是另一个字符的编码序列的前缀，因此在解压缩时，可以根据编码序列逐位识别出每个字符，并将其还原成原始数据。
哈夫曼编码算法的优点在于它能够实现高效的数据压缩，尤其是对于出现频率较高的字符，其编码长度非常短，可以显著减少数据的存储空间。
此外，哈夫曼编码算法还具有良好的可扩展性和适应性，能够适应不同类型、不同大小的数据集。
然而，哈夫曼编码算法也存在一些限制和缺陷。
首先，由于需要统计字符出现的频率，因此在压缩较小的数据集时，其效果可能不如其他压缩算法。
其次，由于哈夫曼编码算法需要在解压缩时构建二叉树，因此对于大规模数据集，其解压缩的时间复杂度可能较高。
为了克服哈夫曼编码算法的这些限制和缺陷，研究者们提出了许多改进和优化的方法。
例如，可以利用哈夫曼编码算法的可扩展性，将其与其他压缩算法结合使用，以实现更高效的数据压缩。
此外，还可以利用多种哈夫曼编码算法的优点，设计出更加灵活、高效的数据压缩方案。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
摘要：哈夫曼树是带权路径长度（WPL）最小的二叉树，通过对哈夫曼算法的研究，提出一种求取哈夫曼树带权路径长度的计算方法和应用。
关键词：哈夫曼算法、二叉树、WPL、编码
1 引言：
哈夫曼树是一种特殊的二叉树，又称最优二叉树：假设有一组（无序）实数｛w1,w2,w3,w4,…,wm｝，现要构造一棵以wi（i=1，2，3，4…，m）为权的m个外部结点的扩充二叉树，使得带权的外部路径长度WPL最小。
满足这一要求的扩充二叉树就称为哈夫曼树或最优二叉树。
若l表示从根到第i个外部结点的路径长度，m为外部结点的个数，wi 为第i个外部结点的权值，则有WPL=∑wili（0<i<=m）。
2 正文：
2.1 算法的基本思想：
（1）由给定的m个权值｛w1,w2,…wm｝，构造一棵由空二叉树扩充得到的扩充二叉树｛T1,T2,…,Tm｝。
每个Ti（1<i<m）只有一个外部结点（也是根结点），它
的权值置为w1。
（2）在已经构造的所有扩充二叉树中，选取根结点的权值最小和次最小的两棵，将它们作为左、右子树，构造成一棵新的扩充二叉树，它的根结点（新建立
的内部结点）的权值为其左、右子树根结点权值之和。
（3）重复执行步骤（2），每次都使扩充二叉树的个数减少一，当只剩下一棵扩充二叉树时，它便是所要构造的哈夫曼树。
一棵二叉树要使其WPL最小，必须使权值的外部结点离根越近，权值越小的离根越远。
2.1.1 程序实现：
/*哈夫曼树的构造方法*/
#include<stdlib.h>
#include<stdio.h>
#define MAXINT 50
#define MAXNUM 50 /* 数组w中最多容纳的元素个数，注意m<=MAXNUM */
#define MAXNODE 100 /* 哈夫曼树中的最大结点数，注意2*m-1<MAXNODE */
structHtNode { /* 哈夫曼树结点的结构*/
intww;
intparent,llink,rlink;
};
structHtTree {
int root;/* 哈夫曼树根在数组中的下标*/
structHtNodeht[MAXNODE];
};
typedefstructHtTree *PHtTree; /* 哈夫曼树类型的指针类型*/
/* 构造具有m个叶结点的哈夫曼树*/
PHtTreehuffman(int m, int *w) {
PHtTreepht;
int i, j, x1, x2, m1, m2;
pht = (PHtTree)malloc(sizeof(structHtTree)); /* 创建空哈夫曼树*/
if (pht == NULL) {
printf("Out of space!! \n");
returnpht;
}
for (i = 0; i < 2*m-1; i++) {/* 置初态*/
pht->ht[i].llink = -1;
pht->ht[i].rlink = -1;
pht->ht[i].parent = -1;
if (i < m)
pht->ht[i].ww = w[i];
else
pht->ht[i].ww = -1;
}
for ( i = 0; i < m-1; i++) {/* 每循环一次构造一个内部结点*/
m1 = MAXINT;
m2 = MAXINT;/* 相关变量赋初值*/
x1 = -1;
x2 = -1;
for (j = 0; j <m+i; j++) /* 找两个最小权的无父结点的结点*/ if (pht->ht[j].ww< m1 &&pht->ht[j].parent == -1) {
m2 = m1;
x2 = x1;
m1 = pht->ht[j].ww;
x1 = j;
}
else if (pht->ht[j].ww< m2 &&pht->ht[j].parent == -1) {
m2 = pht->ht[j].ww;
x2 = j;
}
pht->ht[x1].parent = m+i; /* 构造一个内部结点*/
pht->ht[x2].parent = m+i;
pht->ht[m+i].ww = m1+m2;
pht->ht[m+i].llink = x1;
pht->ht[m+i].rlink = x2;
pht->root = m+i;
}
returnpht;
}
int main() {
int m = 0, j = 0, i = 0, parent = 0;
int* w;
PHtTreepht;
printf("please input m = ");/*输入外部结点个数*/
scanf("%d", &m);
if (m < 1) {
printf("m is not reasonable!\n");
return 1;
}
w = (int *)malloc(sizeof(int)*m);
if (w == NULL) {
printf("overflow!\n");
return 1;
}
printf("please input the %d numbers：\n",m);/*输入权值*/
for (j = 0; j < m; j++)
scanf("%d", w+j);
pht = huffman(m, w);
for (j = 0; j < m; j++) {
printf("the Reverse code of the %d node is:", j+1);/*得到的编码应倒过来*/
i = j;
while (pht->ht[i].parent != -1) {
parent = pht->ht[i].parent;
if (pht->ht[parent].llink == i)
printf("0");
else
printf("1");
i = parent;
}
printf("\n");
}
return 0;
}
2.1.2 例子：
下面以w=｛2,3,5,7,11,13,17,17,19,23,29,31,37,41｝,按照上述方法构造出来的哈夫曼树如下图所示：
用哈夫曼算法构造的哈夫曼树
2.2 哈夫曼树的应用：
2.2.1 哈夫曼编码：
哈夫曼树可以直接应用于通信及数据传送中的二进制编码。
设：
D=｛d1,d2,d3…dn｝为需要编码的字符集合。
W=｛w1,w2,w3,…wn｝为D中各字符出现的频率。
现要对D中的字符进行二进制编码，使得：
（1）按给出的编码传输文件时，通信编码的总长最短。
（2）若di不等于dj，则di的编码不可能是dj的编码的开始部分（前缀）。
满足上述要求的二进制编码称为最优前缀编码。
上述要求的第一条是为了提高传输的速度，第二条是为了保证传输的信息在译码时无二性，所以在字符的编码中间不需要添加任意的分割符。
对于这个问题，可以利用哈夫曼树加以解决：用d1,d2,d3…dn作为外部结点，用w1,w2,w3…wn作为外部结点的权，构造哈夫曼树。
在哈夫曼树中把从每个结点引向其左子结点的边标上二进制数“0”，把从每个结点引向右子节点的边标上二进制数“1”，从根到每个叶结点的路径上的二进制数连接起来，就是这个叶结点所代表字符的最优前缀编码。
通常把这种编码称为哈夫曼编码。
例如：
D=｛d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13｝
W=｛2,3,5,7,11,13,17,19,23,29,31,37,41｝
利用哈夫曼算法构造出如下图所示的哈夫曼树：
用于编码的哈夫曼树
从而得到各字符的编码为：
d1:1011110 d2:1011111
d3:101110 d4:10110
d5:0100 d6:0101
d7:1010 d8:000
d9:001 d10:011
d11:100 d12:110
d13:111
编码的结果是，出现频率大的字符其编码较短，出现频率较小的字符其编码较长。
3 小结：
由于哈夫曼编码是一种最优前缀编码，所以在解码时也十分容易。
只要从二叉树的根结点开始，用需要解码的二进制位串从头开始与二叉树根结点到子结点边上标的0、1相匹配，确定一条到达树叶结点的路径。
一旦达到树叶结点，则译出一个字符。
然后再回到根结点，从二进制串中的下一位开始继续解码。
参考文献：
【1】张乃孝. (2011.6). 算法与数据结构--C语言描述(第3版). 高等教育出版社.。