Question

所以这个场景是你认识的人给你一个霍夫曼树，但它不是最优的（我知道所有的霍夫曼树都是最优的，只是假设它不是最佳的，但确实遵循霍夫曼风格只有叶子有价值）。

该函数应尽可能地改进树而不改变它的实际“形状”，借助于将每个符号映射到它正在压缩的假设文本中的出现次数的字典。该功能通过交换节点来完成此操作。因此，最终结果不一定是最佳树，但它将尽可能地得到改进。例如....

Class Node:
    def __init__(self, item = None, left = None, right = None):
        self.item = item
        self.left = left
        self.right = right

     def __repr__(self):
         return 'Node({}, {}, {})'.format(self.item, self.left, self.right)

字典= {54：12,101：34,29：22,65：3,20：13}

你的朋友送你......

节点（无，节点（无，节点（20），节点（54）），节点（无，节点（65），节点（无，节点（101），节点（29）））

...或

               None  
          /     |     \
     None       |       None
   /      \     |     /      \
20          54  |  65       None
                |         /      \
                |      101        29

想要的结果将是......

节点（无，节点（无，节点（20），节点（29）），节点（无，节点（101），节点（无，节点（65），节点（54）））

...或

               None  
          /     |     \
     None       |       None
   /      \     |     /      \
20          29  |  101       None
                |         /      \
                |       65        54

如何定位叶子节点然后找到它应该在哪里，交换它，然后对所有其他叶子节点执行此操作，同时确保树的形状是相同的，无论它是否是最佳的？这也是在python中。

Answer 1

从构建霍夫曼树的basic technique开始，值最不可能的节点是第一个链接到父节点的节点。这些节点在霍夫曼树内显得比其中任何其他节点更深。从这一点来看，我们可以推断出你去的树内越深，你遇到的值越少。

这个类比对于开发优化函数至关重要，因为我们不需要在第一次正确执行时执行各种交换：获取树中按深度排序的所有项的列表他们的匹配值按顺序排列;每当有叶子时，将它们插入各自的深度。这是我编码的解决方案：

def optimize_tree(tree, dictionary):

    def grab_items(tree):
        if tree.item:
            return [tree.item]
        else:
            return grab_items(tree.left) + grab_items(tree.right)

    def grab_depth_info(tree):
        def _grab_depth_info(tree,depth):
            if tree.item:
                return {depth:1}
            else:
                depth_info_list = [_grab_depth_info(child,depth+1) for child in [tree.left, tree.right]]
                depth_info = depth_info_list[0]
                for depth in depth_info_list[1]:
                    if depth in depth_info:
                        depth_info[depth] += depth_info_list[1][depth]
                    else:
                        depth_info[depth] = depth_info_list[1][depth]
                return depth_info

        return _grab_depth_info(tree,0)

    def make_inverse_dictionary(dictionary):
        inv_dictionary = {}
        for key in dictionary:
            if dictionary[key] in inv_dictionary:
                inv_dictionary[dictionary[key]].append(key)
            else:
                inv_dictionary[dictionary[key]] = [key]

        for key in inv_dictionary:
            inv_dictionary[key].sort()

        return inv_dictionary

    def get_depth_to_items(depth_info,actual_values):
        depth_to_items = {}
        for depth in depth_info:
            depth_to_items[depth] = []
            for i in range(depth_info[depth]):
                depth_to_items[depth].append(actual_values[i])

            depth_to_items[depth].sort()
            del actual_values[:depth+1]

        return depth_to_items

    def update_tree(tree,depth_to_items,reference):
        def _update_tree(tree,depth,depth_to_items,reference):
            if tree.item:
                tree.item = reference[depth_to_items[depth].pop(0)].pop(0)
            else:
                for child in [tree.left,tree.right]:
                    _update_tree(child,depth+1,depth_to_items,reference)
        _update_tree(tree,0,depth_to_items,reference)

    items = grab_items(tree)
    depth_info = grab_depth_info(tree)
    actual_values = [dictionary[item] for item in items]
    actual_values.sort(reverse=True)
    inv_dictionary = make_inverse_dictionary(dictionary)

    depth_to_items = get_depth_to_items(depth_info,actual_values)

    update_tree(tree,depth_to_items,inv_dictionary)

说明：

optimize_tree函数要求用户传入两个参数：

tree：霍夫曼树的根节点。
dictionary：将符号映射到其频率的字典。

该功能通过定义四个内部函数开始：

grab_items是一个接受树并返回其中所有项目列表的函数。
grab_depth_info返回一个字典，其中键是深度级别，值是级别上的节点数。
make_inverse_dictionary返回与给定字典相反的字典。（它可以处理值可以映射到两个键的情况。）
get_depth_to_items返回一个字典，其中键是深度级别，值是应该在该级别的实际值列表（来自字典），以便优化树。
update_tree将项目插入到应该位于的位置，以便对树进行优化。

注意：grab_depth_info和update_tree在其中定义了内部函数，以便它们的功能可以递归地工作。

以下算法需要以下四个内部函数：

首先，该函数从树中获取项目列表和深度信息。
然后，它使用项目列表从给定字典中获取实际值列表，并按降序排列。（因此，最不频繁的值与步骤4中的最大深度级别匹配。）
接下来，它会对给定字典进行反转，其中交换键和值。（这是为了帮助完成第5步。）
完成这些准备工作后，函数会将深度信息和实际值列表传递到get_depth_to_items函数，以获取深度级别的字典，以便列出值的序列。
最后，函数在树中传递，在上一步中生成的字典，以及反转的字典到update_tree函数中，该函数将使用其内部函数递归地转到树中的每个节点，使用原始键从倒置字典中更新item属性。

使用此算法的结果将使您传入的树处于最优化状态，而不会更改其实际形状。

我可以通过执行以下代码行来确认这是有效的：

tree = Node(None, Node(None, Node(20), Node(29)), Node(None, Node(101), Node(None, Node(65), Node(54))))
dictionary = {54: 12, 101: 34, 29: 22, 65: 3, 20: 13}
optimize_tree(tree,dictionary)
print(tree)

这个的输出是：

Node(None, Node(None, Node(20, None, None), Node(29, None, None)), Node(None, Node(101, None, None), Node(None, Node(65, None, None), Node(54, None, None))))

优化二叉树函数，霍夫曼树

1 个答案:

说明：