Python实现霍夫曼树

Python实现霍夫曼树

霍夫曼树是一种特殊的二叉树，是一种带权路径长度最短的二叉树，又称为最优二叉树。

给定 N 个权值作为二叉树的 N 个叶节点的权值，构造一棵二叉树，若该二叉树的带权路径长度达到最小，则称该二叉树为霍夫曼树。

霍夫曼树中权值越大的节点离根越近。

霍夫曼树主要应用于信息编码和数据压缩领域，是现代压缩算法的基础。

一、霍夫曼树的相关术语

霍夫曼树要满足带权路径长度最小，那就要知道什么是权值？什么是路径？什么是带权路径长度？

1. 路径

在一棵树中，从一个节点往下可以到达子节点或子孙节点的通路，称为路径。

2. 节点的权值

在具体的应用场景中，二叉树的每个节点对应着具体的业务含义，每个节点有不同的权重，节点的权重值被称为节点的权值。

如下图中节点C的权值为5。

3. 节点的路径长度

根节点处于二叉树的第1层，则二叉树中第L层的节点的路径长度为 L-1 。

如上图中节点 F 处于二叉树的第三层，则 F 的路径长度为 3-1 = 2 。

节点的路径长度也可以这么理解，如果每个节点到达它的子节点的路径记为一个路径单元，则从根节点开始，到达某节点的路径单元数称为该节点的路径长度。

4. 节点的带权路径长度

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

如上图中节点 D 的权值为 18、路径长度为 2，则节点 D 的带权路径长度为 18*2 = 36。

5. 树的带权路径长度

树的所有叶节点的带权路径长度之和，称为树的带权路径长度，记为WPL(Weighted Path Length of Tree)。

如上图中的二叉树的带权路径长度为 WPL = 18*2 + 7*2 + 6*2 + 17*2 = 96

二、霍夫曼树的构造过程

给定 N 个权值作为二叉树的 N 个叶节点的权值，构造一棵二叉树，可以构建出多种不同结构的二叉树，不同结构的二叉树的带权路径长度不一定相等。只有当二叉树的带权路径长度最小时，二叉树才是霍夫曼树。

如给定 3,5,7,13 四个权值作为叶节点的权值，构造四个叶节点的二叉树可以有很多种不同的结构，下面例举出了其中两种，左边的二叉树的带权路径长度为 3*3 + 5*2 + 7*2 + 13*2 = 59，右边的二叉树的带权路径长度为 13*1 + 7*2 + 3*3 + 5*3 = 51。根据霍夫曼树的特性，权值越大的节点离根越近，也就是说权值越大的节点路径越短，下图中右边的二叉树就是一棵霍夫曼树，树的带权路径长度已经达到了最小。

那么，怎么根据给定的叶节点权值构建一棵霍夫曼树呢？在构造霍夫曼树前，先推导一些霍夫曼树的一般属性。

1. 要保证构造出来的二叉树是霍夫曼树，就要让权值大的节点的路径尽量短，反过来，权值小的节点就只能处于二叉树的更高层，把路径短的位置让给权值大的节点。从局部看，只要保证每个节点的路径都不大于权值比它小的节点即可，所以可以使用贪婪算法。

2. 霍夫曼树中不会存在只有一个子节点的节点。假设霍夫曼树中存在只有一个子节点的节点，如果删除该节点，它的子树中的所有叶节点的路径长度都可以减1，可以构造出带权路径长度更小的二叉树，这与霍夫曼树的定义矛盾，所以假设不成立。

3. 如果霍夫曼树只有两个叶节点，则两个叶节点的路径相等，都为 1。

根据这些属性，开始构造霍夫曼树，步骤如下：

1. 将有 N 个叶节点的树看成 N 棵树的森林(每棵树仅有一个根节点)。

以 3,5,7,13 为例。

2. 从森林中选出根节点权值最小的两棵树，分别作为新树的左右子树(这样构造新树满足霍夫曼树)，且新树的根节点权值为其左右子树根结点的权值之和。然后将被合并的两棵树从森林中删除，将新树添加到森林中。

从中选出最小的 3 和 5，合并成一棵霍夫曼树，然后将新树添加到森林中。

3. 重复步骤 2 ，直到森林中只剩一棵树为止，最后的树即为霍夫曼树。

为了保证霍夫曼树的结构唯一，本文中每次合并时都将根节点权值小的树作为左子树，根节点权值大的树作为右子树。这个可以自己定，因为只要树的带权路径长度达到了最小，不管什么结构，都是霍夫曼树，霍夫曼树不是唯一的。

继续选出最小的 7 和 8，合并。

最终得到的霍夫曼树结构如下。

现在验证一下，树的带权路径长度为 WPL = 13*1 + 7*2 + 3*3 + 5*3 = 51，权值越大的节点路径越短，所以这是一棵霍夫曼树。

三、Python实现霍夫曼树

1. 代码准备

# coding=utf-8
class Node(object):
    def __init__(self, data):
        self.data = data
        self.parent = None
        self.left_child = None
        self.right_child = None
        self.is_in_tree = False


class HuffmanTree(object):
    """霍夫曼树"""
    def __init__(self):
        self.__root = None
        self.prefix_branch = '├'
        self.prefix_trunk = '|'
        self.prefix_leaf = '└'
        self.prefix_empty = ''
        self.prefix_left = '─L─'
        self.prefix_right = '─R─'

    def is_empty(self):
        return not self.__root

    @property
    def root(self):
        return self.__root

    @root.setter
    def root(self, value):
        self.__root = value if isinstance(value, Node) else Node(value)

    def show_tree(self):
        if self.is_empty():
            print('空二叉树')
            return
        print('-' * 20)
        print(self.__root.data)
        self.__print_tree(self.__root)
        print('-' * 20)

    def __print_tree(self, node, prefix=None):
        if prefix is None:
            prefix, prefix_left_child = '', ''
        else:
            prefix = prefix.replace(self.prefix_branch, self.prefix_trunk)
            prefix = prefix.replace(self.prefix_leaf, self.prefix_empty)
            prefix_left_child = prefix.replace(self.prefix_leaf, self.prefix_empty)
        if self.has_child(node):
            if node.right_child is not None:
                print(prefix + self.prefix_branch + self.prefix_right + str(node.right_child.data))
                if self.has_child(node.right_child):
                    self.__print_tree(node.right_child, prefix + self.prefix_branch + ' ')
            else:
                print(prefix + self.prefix_branch + self.prefix_right)
            if node.left_child is not None:
                print(prefix + self.prefix_leaf + self.prefix_left + str(node.left_child.data))
                if self.has_child(node.left_child):
                    prefix_left_child += '  '
                    self.__print_tree(node.left_child, self.prefix_leaf + prefix_left_child)
            else:
                print(prefix + self.prefix_leaf + self.prefix_left)

    def has_child(self, node):
        return node.left_child is not None or node.right_child is not None

先创建一个节点类 Node，用于创建霍夫曼树的节点，这里要注意一点，因为在构造霍夫曼树时，要不断从一个森林中选根节点最小的两棵树进行合并，所以在节点里添加一个标志位，is_in_tree，如果为 True 则表示该树已经合并到霍夫曼树中了，不会重复取。

提前实现一个霍夫曼树的类 HuffmanTree ，先准备了一个按树形结构打印霍夫曼树的方法 show_tree() 。

下面根据霍夫曼树的构造过程，实现霍夫曼树的构造方法。

    def huffman(self, leavers):
        """构造霍夫曼树"""
        if len(leavers) <= 0:
            return
        if len(leavers) == 1:
            self.root = Node(leavers[0])
            return
        woods = list()
        for i in range(len(leavers)):
            woods.append(Node(leavers[i]))
        while len(woods) < 2*len(leavers) - 1:
            node1, node2 = Node(float('inf')), Node(float('inf'))
            for j in range(len(woods)):
                if node1.data > node2.data:
                    node1, node2 = node2, node1
                if woods[j].data < node1.data and woods[j].is_in_tree is False:
                    node1, node2 = woods[j], node1
                elif node1.data <= woods[j].data < node2.data and woods[j].is_in_tree is False:
                    node2 = woods[j]
            parent_node = Node(node1.data + node2.data)
            woods.append(parent_node)
            parent_node.left_child, parent_node.right_child = node1, node2
            self.root, node1.parent, node2.parent = parent_node, parent_node, parent_node
            node1.is_in_tree, node2.is_in_tree = True, True

huffman(leavers): 构造霍夫曼树。构造霍夫曼树时会给定 N 个权值，如果 N<=0，则直接返回。如果 N=1，则直接将该权值作为根节点的权值，即可构建出霍夫曼树。如果 N>=2，则先将这 N 个权值作为根节点的权值构建一个包含 N 棵树的森林，再从森林中选根节点权值最小的两棵树进行合并，一直循环直到只剩一棵树。

在这个方法中，有以下几点需要注意，否则很容易出错：

1. 代码里为了方便处理，并没有将被合并的树从列表 woods 中删除(删除操作很麻烦，尤其权值相等时)，而是通过修改根节点的标志位 is_in_tree，如果 is_in_tree 为 True，表示该树已经被合并了，不会重复取。

那怎么判断霍夫曼树已经构造完成了呢，当 woods 中只剩一棵树的根节点的标志位 is_in_tree 为 False 时，但是，这样不好判断，每次合并后都要判断一遍 woods 中的根节点标志位。根据前面分析的属性，使用贪婪算法，每次合并树时，新的树都是一棵局部的霍夫曼树，并且霍夫曼树中不会存在只有一个子节点的节点。在构造霍夫曼树的过程中，每个节点都作为一棵树的根节点被添加到森林 woods 中了，所以 woods 的长度等于霍夫曼树的节点数，当 woods 的长度达到霍夫曼树的节点总数时，霍夫曼树就构造完成。

霍夫曼树中除了叶节点，其他节点都有两个子节点，根据二叉树的特性，当叶节点数为 N 时，有两个子节点的节点数为 N+1，所以有 N 个叶节点的霍夫曼树的节点数为 2*N + 1 。

2. 为了获取到权值最小的两个根节点，提前声明了两个变量 node1 和 node2 ，这两个变量可以提前赋值为两个权值很大的节点，建议直接使用正无穷大 float('inf')，如果一开始赋值为 woods 中的第一个和第二个，当第一个或第二个值就是最小值时，可能会每次循环都取到相同的值。

3. 在寻找权值最小的两个根节点值时，如果当前节点 node 的权值小于 node1 的权值，node.data < node1.data ，则将 node1 赋值给 node2，将 node 赋值给 node1，如果当前节点 node 的权值大于等于 node1 的权值同时小于 node2 的权值，node1.data <= node.data < node2.data，则将 node 赋值给 node2。这里很容易忽略第二种情况。

if __name__ == '__main__':
    tree = HuffmanTree()
    leavers = [11, 5, 7, 13, 17, 11]
    tree.huffman(leavers)
    tree.show_tree()

运行结果：

--------------------
64
├─R─39
| ├─R─22
| | ├─R─11
| | └─L─11
| └─L─17
└─L─25
  ├─R─13
  └─L─12
    ├─R─7
    └─L─5
--------------------

给定的 N 个叶节点权值为 [11, 5, 7, 13, 17, 11] ，霍夫曼树结构如下图。

该霍夫曼树的带权路径长度为 WPL = 13*2 + 17*2 + 5*3 + 7*3 + 11*3 + 11*3 = 162 。