数据结构_哈夫曼树(python实现)
哈夫曼树是一种重要的数据结构，用于压缩和编码数据。它由经典的数学家和计算机科学家大卫哈夫曼在20世纪50年代发明。哈夫曼树的目的是为了在编码和解码数据中，尽可能地减少所需的比特数。换句话说，它可以将大量数据压缩为在传输过程中所需的最小比特数。
在NLP领域的词向量开篇制作Word2Vec中用到了一种softmax优化方法——层次softmax，就是将词频编码成哈夫曼树的形式，然后，（以skip-gram为例）在样本[v, w]进入模型前，将周围词w，基于哈夫曼树映射成从根到叶路径两个方向路径right_path=[p1, p2]; left_path=[n1, n2]，最终组成[[v, p1], [v, p2]]; [[v, n1], [v, n2]，最后以v, p, v, n 四个一维向量的方式进入模型。
一、哈夫曼树构建伪代码
哈夫曼树的构建过程非常简单，可以分为以下几个步骤：
- 根据数据出现的频率创建叶子节点，频率越高的字母对应的节点越靠近根节点。
- 对于两个字符的节点（由频率最低的字符所对应的节点）之间创建一个父节点。父节点的权重等于其两个子节点权重之和。
- 重复步骤2，直到所有的节点都被合并到同一个根节点下。
哈夫曼树构建图示
二、哈夫曼树构建python
借助优先队列headq 便于快速输出最小的2个节点
import heapq
class Node:
def __init__(self, idx, freq, char, left, right):
self.idx = idx
self.freq = freq
self.char = char
self.left = left
self.right = right
def __lt__(self, other):
return self.freq < other.freq
def __str__(self):
return f'Node([{self.idx}]({self.char}/{self.freq}), left={self.left}, right={self.right})'
def __repr__(self):
return str(self)
def build_huffman_tree(data=None, freq_map=None):
if freq_map is None:
freq_map = dict()
for char in data:
freq_map[char] = freq_map.get(char, 0) + 1
print(freq_map)
word_map = [Node(idx, freq, char, None, None) for idx, (char, freq) in enumerate(freq_map.items())]
min_node = min(word_map)
print(min_node)
print('len(word_map)=', len(word_map))
# 初始化 因为heappop 会先输出第一个元素
node_heap = [min_node] + [Node(idx, freq, char, None, None) for idx, (char, freq) in enumerate(freq_map.items()) if char != min_node.char]
# 构建哈夫曼树
while len(node_heap) > 1:
# 优先队列， 弹出最小的2个
left_node = heapq.heappop(node_heap)
right_node = heapq.heappop(node_heap)
freq_sum = left_node.freq + right_node.freq
idx = len(word_map)
# 左大右小
combined_node = Node(idx, freq_sum, None, right_node, left_node)
heapq.heappush(node_heap, combined_node)
word_map.append(combined_node)
# 哈夫曼树最后
print('len(word_map)=', len(word_map))
return node_heap[0], word_map
if __name__ == "__main__":
test_dict = {
'a': 6, 'b': 3,
'c': 4, 'd': 2
}
huffman_tree, total_word_map = build_huffman_tree(freq_map=test_dict)
print(huffman_tree)
结果
res = """
Node([6](None/15),
left=Node([5](None/9),
left=Node([4](None/5),
left=Node([1](b/3), left=None, right=None),
right=Node([3](d/2), left=None, right=None)
),
right=Node([2](c/4), left=None, right=None)
),
right=Node([0](a/6), left=None, right=None)
)
"""
2.1 哈夫曼code & path
哈夫曼树已经构成了，哈夫曼code生成就简单了
基本思路就是： 当前节点的code = 父节点code + [当前方向code]
用队列来做辅助：存储未处理的节点
import heapq
from collections import deque
class Node:
def __init__(self, idx, freq, char, left, right):
self.idx = idx
self.freq = freq
self.char = char
self.left = left
self.right = right
self.code = []
self.path = []
def __lt__(self, other):
return self.freq < other.freq
def __str__(self):
return f'Node([{self.idx}]({self.char}/{self.freq}), left={self.left}, right={self.right})'
def __repr__(self):
return str(self)
def build_huffman_tree(data=None, freq_map=None):
if freq_map is None:
freq_map = dict()
for char in data:
freq_map[char] = freq_map.get(char, 0) + 1
print(freq_map)
word_map = [Node(idx, freq, char, None, None) for idx, (char, freq) in enumerate(freq_map.items())]
min_node = min(word_map)
print(min_node)
print('len(word_map)=', len(word_map))
# 初始化 因为heappop 会先输出第一个元素
node_heap = [min_node] + [i for i in word_map if i.char != min_node.char]
# 构建哈夫曼树
while len(node_heap) > 1:
# 优先队列， 弹出最小的2个
left_node = heapq.heappop(node_heap)
right_node = heapq.heappop(node_heap)
freq_sum = left_node.freq + right_node.freq
idx = len(word_map)
# 左大右小
combined_node = Node(idx, freq_sum, None, right_node, left_node)
heapq.heappush(node_heap, combined_node)
word_map.append(combined_node)
# 哈夫曼树最后
print('len(word_map)=', len(word_map))
h_tree = complete_code_path(node_heap[0])
return h_tree, word_map
def complete_code_path(h_tree):
help_list = deque()
h_tree.path = [h_tree.idx]
h_tree.code = [-1]
help_list.append(h_tree)
while len(help_list):
n = help_list.popleft()
while n.left:
l = n.left
r = n.right
l.code = n.code + [1]
r.code = n.code + [0]
l.path = n.path + [l.idx]
r.path = n.path + [r.idx]
help_list.append(r)
n = l
return h_tree
if __name__ == '__main__':
test_dict = {
'a': 6, 'b': 3,
'c': 4, 'd': 2
}
h_tree, total_word_map = build_huffman_tree(freq_map=test_dict)
for i in total_word_map:
print('--'*25)
print(i)
print('code=', i.code)
print('path=', i.path)
结果如下
Node([3](d/2), left=None, right=None)
len(word_map)= 4
len(word_map)= 7
--------------------------------------------------
Node([0](a/6), left=None, right=None)
code= [-1, 0]
path= [6, 0]
--------------------------------------------------
Node([1](b/3), left=None, right=None)
code= [-1, 1, 1, 1]
path= [6, 5, 4, 1]
--------------------------------------------------
Node([2](c/4), left=None, right=None)
code= [-1, 1, 0]
path= [6, 5, 2]
--------------------------------------------------
Node([3](d/2), left=None, right=None)
code= [-1, 1, 1, 0]
path= [6, 5, 4, 3]
--------------------------------------------------
Node([4](None/5), left=Node([1](b/3), left=None, right=None), right=Node([3](d/2), left=None, right=None))
code= [-1, 1, 1]
path= [6, 5, 4]
--------------------------------------------------
Node([5](None/9), left=Node([4](None/5), left=Node([1](b/3), left=None, right=None), right=Node([3](d/2), left=None, right=None)), right=Node([2](c/4), left=None, right=None))
code= [-1, 1]
path= [6, 5]
--------------------------------------------------
Node([6](None/15), left=Node([5](None/9), left=Node([4](None/5), left=Node([1](b/3), left=None, right=None), right=Node([3](d/2), left=None, right=None)), right=Node([2](c/4), left=None, right=None)), right=Node([0](a/6), left=None, right=None))
code= [-1]
path= [6]