不用优先队列建霍夫曼树的技巧

一分耕耘，一分收获！既然都打开这篇《不用优先队列构建霍夫曼树的技巧》，就坚持看下去，学下去吧！本文主要会给大家讲到等等知识点，如果大家对本文有好的建议或者看到有不足之处，非常欢迎大家积极提出！在后续文章我会继续更新文章相关的内容，希望对大家都有所帮助！

本文将介绍一种在不使用优先队列的情况下构建霍夫曼树的有效方法。通过初始对符号及其频率进行升序排序，并巧妙地利用两个有序列表（原始符号列表和已合并节点列表）来迭代地选取并合并最小的两个节点，可以高效地构建霍夫曼树，避免了优先队列的复杂性。

霍夫曼树与优先队列的传统关联

霍夫曼树（Huffman Tree），又称最优二叉树，是一种用于数据压缩的二叉树结构。它通过为出现频率高的字符分配较短的编码，为出现频率低的字符分配较长的编码，从而实现对数据的有效压缩。构建霍夫曼树的核心思想是每次选择当前频率最小的两个节点进行合并，直到只剩下一个根节点。在传统的霍夫曼树构建算法中，优先队列（Priority Queue）是实现这一“每次选择最小”操作的理想数据结构，因为它能高效地（通常为O(log N)时间复杂度）提取最小元素。

然而，在某些特定场景或教学要求下，可能需要避免使用优先队列。这时，我们需要一种替代方案来模拟优先队列的行为，即高效地找到并移除最小的两个节点。

不使用优先队列构建霍夫曼树的巧妙方法

这种替代方法的核心在于利用两个已排序的列表来管理待合并的节点，从而避免了每次全局搜索最小值的开销。其基本原理是：一旦两个节点合并成一个新节点，这个新节点的频率必然大于或等于其两个子节点的频率。因此，新节点的频率通常会比之前已合并的节点更大，或者至少不会更小。这使得我们可以在一个专门用于存放已合并节点的新列表中，保持其元素的有序性。

以下是详细的构建步骤：

1. 初始化符号列表： 创建一个包含所有原始符号及其对应频率的列表。这个列表中的每个元素可以是一个包含符号及其频率的元组或对象。 例如：[('a', 5), ('b', 9), ('c', 12), ('d', 13), ('e', 16), ('f', 45)]

2. 对初始列表进行排序： 将第一步创建的符号列表按照频率进行升序排序。 例如：[('a', 5), ('b', 9), ('c', 12), ('d', 13), ('e', 16), ('f', 45)] (假设已经是升序)

3. 创建空合并节点列表： 创建一个空的列表，用于存放后续合并产生的新节点（内部节点）。这个列表也将始终保持频率升序。

4. 迭代合并节点： 当两个列表（原始符号列表和合并节点列表）中的节点总数大于1时，重复以下操作：

   • 选取最小的两个节点： 从原始符号列表的头部和合并节点列表的头部中，比较当前最小的元素。

     • 如果原始符号列表为空，则从合并节点列表的头部取出两个最小节点。
     • 如果合并节点列表为空，则从原始符号列表的头部取出两个最小节点。
     • 如果两个列表都不为空，则比较两个列表头部的元素频率，选择频率最小的那个作为第一个节点。然后，从剩余的两个列表头部中再次选择频率最小的那个作为第二个节点。
     • 注意： 每次取出节点后，要从对应的列表中移除该节点。

   • 合并节点： 将选出的两个节点合并成一个新的父节点。新节点的频率是两个子节点频率之和，其左右子节点分别为被合并的两个节点。

   • 将新节点添加至合并节点列表： 将新创建的父节点添加到合并节点列表的末尾。由于新节点的频率总是大于或等于其子节点的频率，且我们总是从当前最小的节点开始合并，因此新节点的频率将大于或等于合并节点列表中所有现有节点的频率。这意味着合并节点列表将自动保持升序排列，无需再次排序。

5. 构建完成： 当循环结束时，只剩下一个节点，它就是霍夫曼树的根节点。

示例代码（Python 风格伪代码）

为了更好地理解上述过程，我们使用 Python 风格的伪代码来演示：

class Node:
    def __init__(self, char=None, freq=0, left=None, right=None):
        self.char = char  # 字符，对于内部节点为None
        self.freq = freq  # 频率
        self.left = left  # 左子节点
        self.right = right # 右子节点

    def __lt__(self, other): # 用于排序比较
        return self.freq < other.freq

def build_huffman_tree_without_priority_queue(symbols_with_freq):
    # 1. 初始化符号列表并创建节点对象
    nodes = [Node(char, freq) for char, freq in symbols_with_freq.items()]

    # 2. 对初始列表进行升序排序
    nodes.sort()

    # 3. 创建空合并节点列表
    merged_nodes = []

    # 辅助函数：从两个列表中获取最小节点
    def get_min_node(list1, list2):
        if not list1:
            return list2.pop(0)
        if not list2:
            return list1.pop(0)
        if list1[0].freq < list2[0].freq:
            return list1.pop(0)
        else:
            return list2.pop(0)

    # 4. 迭代合并节点
    while len(nodes) + len(merged_nodes) > 1:
        # 选取最小的两个节点
        node1 = get_min_node(nodes, merged_nodes)
        node2 = get_min_node(nodes, merged_nodes)

        # 合并节点
        new_freq = node1.freq + node2.freq
        new_node = Node(freq=new_freq, left=node1, right=node2)

        # 将新节点添加至合并节点列表末尾
        merged_nodes.append(new_node)
        # 注意：由于新节点的频率总是大于或等于现有合并节点列表中的元素，
        # 且我们总是从最小的元素开始合并，因此merged_nodes列表始终保持有序。
        # 实际实现中，如果需要严格保持有序，可以使用bisect模块进行插入，
        # 但对于霍夫曼树的这种特定合并逻辑，append即可。
        # 在这里，由于每次append的元素都比当前列表末尾的元素大，所以append是有效的。
        # 如果不是严格递增，则需要插入排序。但霍夫曼树的合并特性保证了递增。

    # 5. 返回最终的根节点
    if nodes:
        return nodes[0]
    else:
        return merged_nodes[0]

# 示例使用
frequencies = {'a': 5, 'b': 9, 'c': 12, 'd': 13, 'e': 16, 'f': 45}
huffman_root = build_huffman_tree_without_priority_queue(frequencies)

# 后续可以遍历huffman_root来生成霍夫曼编码

注意事项与总结

• 时间复杂度： 这种方法的初始排序步骤的时间复杂度为 O(N log N)，其中 N 是符号的数量。随后的合并过程，每次操作（选取两个最小节点，合并，添加）的时间复杂度是常数（因为列表头部操作是 O(1)）。总共有 N-1 次合并操作，所以合并阶段的总时间复杂度为 O(N)。因此，整体时间复杂度由初始排序决定，为 O(N log N)。这与使用优先队列的霍夫曼树构建方法（N 次插入和 N-1 次提取最小，每次 O(log N)）具有相同的时间复杂度。
• 空间复杂度： 需要额外的空间来存储节点对象和两个列表，空间复杂度为 O(N)。
• 适用场景： 这种方法在教学或特定项目要求不能使用优先队列时非常有用。它展示了如何通过巧妙的数据结构管理来达到与优先队列相似的效果。
• 理解深度： 这种“双列表排序”的技巧不仅能构建霍夫曼树，也体现了对算法细节和数据结构特性的深刻理解。它强调了在某些特定场景下，通过分析操作的性质来优化数据结构选择的可能性。

通过这种不依赖优先队列的方法，我们依然能够高效且正确地构建霍夫曼树，这为算法设计提供了另一种思路，并加深了对霍夫曼编码原理的理解。

理论要掌握，实操不能落！以上关于《不用优先队列建霍夫曼树的技巧》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！