构建Huffman哈夫曼最优二叉树,binarytree,Python

Huffman Tree,哈夫曼树(又被称为霍夫曼树、赫夫曼树),是一种基于贪心算法思想构建的二叉树,贪心算法寻求在建树过程中局部最优,最终迭代达到全局最优,从中可以看出,Huffman树的构建也体现了动态规划思想。Huffman Tree的贪心算法思想,寻找一种二叉树,使得WPL带路权的最小二叉树,因此,哈夫曼树也称为最优二叉树。

现在基于binarytree,用Python构建哈夫曼树:

  1. import random
  2. from binarytree import Node
  3. def app():
  4. data = []
  5. # 生成随机测试数据。
  6. for i in range(5):
  7. data.append(random.randint(1, 50))
  8. random.shuffle(data)
  9. print(data)
  10. huffman_tree = build_huffman_tree(data)
  11. print('-----')
  12. print('最终的Huffman树')
  13. print(huffman_tree.pop())
  14. print('---')
  15. print(data)
  16. def build_huffman_tree(data):
  17. nodes = []
  18. for i in data:
  19. nodes.append(Node(i))
  20. print('nodes', nodes)
  21. print('开始构建Huffman树')
  22. while True:
  23. print('-')
  24. nodes = sorted(nodes, key=lambda x: x.value)
  25. print('nodes', nodes)
  26. if len(nodes) == 1:
  27. print('仅剩一个节点,建树结束')
  28. break
  29. left = nodes.pop(0)
  30. right = nodes.pop(0)
  31. print('选取节点', left.value, right.value)
  32. root = Node(left.value + right.value)
  33. root.left = left
  34. root.right = right
  35. nodes.append(root)
  36. return nodes
  37. if __name__ == '__main__':
  38. app()

测试几轮算法日志输出:

  1. [22, 26, 29, 10, 24]
  2. nodes [Node(22), Node(26), Node(29), Node(10), Node(24)]
  3. 开始构建Huffman
  4. -
  5. nodes [Node(10), Node(22), Node(24), Node(26), Node(29)]
  6. 选取节点 10 22
  7. -
  8. nodes [Node(24), Node(26), Node(29), Node(32)]
  9. 选取节点 24 26
  10. -
  11. nodes [Node(29), Node(32), Node(50)]
  12. 选取节点 29 32
  13. -
  14. nodes [Node(50), Node(61)]
  15. 选取节点 50 61
  16. -
  17. nodes [Node(111)]
  18. 仅剩一个节点,建树结束
  19. -----
  20. 最终的Huffman
  21. ____111___
  22. / \
  23. _50 _61___
  24. / \ / \
  25. 24 26 29 _32
  26. / \
  27. 10 22
  28. ---
  29. [22, 26, 29, 10, 24]
  30. [21, 38, 18, 27, 5]
  31. nodes [Node(21), Node(38), Node(18), Node(27), Node(5)]
  32. 开始构建Huffman
  33. -
  34. nodes [Node(5), Node(18), Node(21), Node(27), Node(38)]
  35. 选取节点 5 18
  36. -
  37. nodes [Node(21), Node(23), Node(27), Node(38)]
  38. 选取节点 21 23
  39. -
  40. nodes [Node(27), Node(38), Node(44)]
  41. 选取节点 27 38
  42. -
  43. nodes [Node(44), Node(65)]
  44. 选取节点 44 65
  45. -
  46. nodes [Node(109)]
  47. 仅剩一个节点,建树结束
  48. -----
  49. 最终的Huffman
  50. _________109___
  51. / \
  52. _44__ _65
  53. / \ / \
  54. 21 23 27 38
  55. / \
  56. 5 18
  57. ---
  58. [21, 38, 18, 27, 5]
  59. [15, 2, 13, 31, 44]
  60. nodes [Node(15), Node(2), Node(13), Node(31), Node(44)]
  61. 开始构建Huffman
  62. -
  63. nodes [Node(2), Node(13), Node(15), Node(31), Node(44)]
  64. 选取节点 2 13
  65. -
  66. nodes [Node(15), Node(15), Node(31), Node(44)]
  67. 选取节点 15 15
  68. -
  69. nodes [Node(30), Node(31), Node(44)]
  70. 选取节点 30 31
  71. -
  72. nodes [Node(44), Node(61)]
  73. 选取节点 44 61
  74. -
  75. nodes [Node(105)]
  76. 仅剩一个节点,建树结束
  77. -----
  78. 最终的Huffman
  79. _105______________
  80. / \
  81. 44 _________61
  82. / \
  83. _30__ 31
  84. / \
  85. 15 15
  86. / \
  87. 2 13
  88. ---
  89. [15, 2, 13, 31, 44]

发表评论

表情:
评论列表 (有 0 条评论,98人围观)

还没有评论,来说两句吧...

相关阅读

    相关 ...

    写在前面 之前讲的链表,栈,队列等都是线性存储结构,都是一对一的关系。而树是具有一对多关系的数据结构。比如我们经常说的湖北省武汉市,湖南长沙的一个类图,就类似于一颗倒转的

    相关 )Java实现

    此篇博客讲最优二叉树也叫哈夫曼树的原理,以及构建步骤,还有哈夫曼编码原理。建议有二叉树基础朋友学习交流。对二叉树基础可以看我的另外一篇博客[二叉树的构建以及遍历][Link 1

    相关 -(Haffman)

    最优二叉树,也称为哈夫曼树,是指对于一组带有确定权值的叶结点,构造的具有最小带权路径长度的二叉树。 设二叉树具有n个带权值的叶子结点,则从根结点到每一个叶子结点的路径长度与该