重學數據結構之哈夫曼樹

1、哈夫曼樹

1.帶權擴充二叉樹的外部路徑長度

　　擴充二叉樹的外部路徑長度，即根到其葉子節點的路徑長度之和。

　　例以下面這兩種帶權擴充二叉樹：

　　

　　左邊的二叉樹的外部路徑長度爲：(2 + 3 + 6 + 9) * 2 = 38。

　　右邊的二叉樹的外部路徑長度爲：9 + 6 * 2 + (2 + 3) * 3 = 36。

2.哈夫曼樹

　　哈夫曼樹（Huffman Tree）是一種重要的二叉樹，在信息領域有重要的理論和實際價值。

　　設有實數集 W = {W₀ ，W₁ ，···，W_m-1 }，T 是一顆擴充二叉樹，其 m 個外部節點分別以 W_i (i = 1, 2, n - 1) 爲權，並且 T 的帶權外部路徑長度在全部這樣的擴充二叉樹中達到最小，則稱 T 爲數據集 W 的最優二叉樹或者哈夫曼樹。

 

2、哈夫曼算法

1.基本概念

　　哈夫曼（D.A.Huffman）提出了一個算法，它能從任意的實數集合構造出與之對應的哈夫曼樹。這個構造算法描述以下：

• 算法的輸入爲實數集合 W = {W₀ ，W₁ ，···，W_m-1 }。
• 在構造中維護一個包含 k 個二叉樹集合的集合 F，開始時k = m 且 F = {T₀ ，T₁ ，···，T_m-1 }，其中每一個 T_i 是一顆只包含權爲 W_i 的根節點的二叉樹。

　　該算法的構造過程當中會重複執行如下兩個步驟，直到集合 F 中只剩下一棵樹爲止：

1. 構造一顆二叉樹，其左右子樹是從集合 F 中選取的兩顆權值最小的二叉樹，其根節點的權值設置爲這兩顆子樹的根節點的權值之和。
2. 將所選取的兩顆二叉樹從集合 F 中刪除，把新構造的二叉樹加入到集合 F 中。　

　　注意：給定集合 W 上的哈夫曼樹並不惟一！

2.示例

　　對於實數集合 W = {2, 1, 3, 7, 8, 4, 5}，下面的圖1到圖7表示了從這個實數集合開始，構造一個哈夫曼樹的過程：

　　圖1：

 　　圖2：

 

 　　圖3：

 

　　圖4： 　　

　　圖5： 

 

　　圖6： 

 

　　圖7： 

 

 

3、哈夫曼算法的實現

1.實現思路

　　要實現哈夫曼算法，須要維護一組二叉樹，並且要知道每顆二叉樹的根節點的權值 ，這個可使用前面定義的二叉樹的節點來構造哈夫曼樹，只須要在根節點處記錄該樹的權值。而在執行算法時

　　在算法開始時，須要根據傳入的實數集和來建立一組單節點的二叉樹，並以權值做爲其優先級存入一個優先級隊列之中，在以後的過程當中反覆執行如下兩步，直至隊列中只有一顆二叉樹：

　　1）從該優先級隊列中取出兩顆權值最小的二叉樹；

　　2）建立一顆新的二叉樹，其權值爲選出的兩棵樹的權值之和，其左右子樹分別爲選出的兩顆樹，並將建立好的二叉樹加入到優先級隊列中。

　　當整個優先級隊列中只剩下一顆二叉樹的時候，就獲得咱們須要的哈夫曼樹了。

2.實現代碼

　　首先是要對哈夫曼樹的節點進行定義，主要是增長一個權值，定義哈夫曼樹節點的代碼以下：

1 # 哈夫曼樹節點
2 class HNode(Node):
3     def __init__(self, value=None, left=None, right=None, weight=None):
4         super(HNode, self).__init__()
5         self.value = value
6         self.left = left
7         self.right = right
8         self.weight = weight

　　而後還須要一個優先級的隊列，在我前面寫過的一篇隊列的博客中有提到，只不過那篇博客裏的優先級隊列用的是一個最大堆，而在這裏須要用最小堆，這樣每次才能取出權值最小的樹。

　　最後，下面就是實現哈夫曼算法的主要代碼了：

 1 def create(weights: list):
 2     """
 3     根據傳入的權值列表建立一個哈夫曼樹
 4     :param weights: 實數集合
 5     """
 6     queue = PriorityQueue()
 7     # 將節點添加到優先級隊列中
 8     for weight in weights:
 9         node = HNode(weight=weight)
10         queue.enqueue(node, weight)
11     while queue.size() > 1:
12         node1 = queue.dequeue()
13         node2 = queue.dequeue()
14         new_node = HNode(left=node1, right=node2, weight=node1.weight + node2.weight)
15         queue.enqueue(new_node, new_node.weight)
16     return queue.dequeue()

 

4、哈夫曼編碼問題

1.問題描述 

　　最優編碼問題，給定兩個集合 C 和 W，C 爲基本數據集合，W 爲 C 中各個字符在實際信息傳遞中使用的頻率，要求設定一套編碼規則，要求： 1）使用這種編碼規則的開銷最小； 2）對任意一對不一樣字符 Ci 和 Cj，要求 Ci 的編碼不是 Cj 編碼的前綴。

2.問題分析

　　使用哈夫曼算法構建一顆哈夫曼樹，這棵樹的葉子節點的數量和字符數量一致，葉子節點的值就是字符的值，葉子節點的權值就是該字符對應的使用頻率。而後從根節點開始遍歷，往左子樹遍歷時標記爲0，往右子樹遍歷時標記爲1，這樣就能保證走到葉子節點時所標記的路徑結果是不同的了，最後將每一個葉子節點的值和對應的標記結果返回，就是題目所求的最優編碼。

　　例如輸入的數據爲：{"A": 2, "b": 3, "c": 5, "d": 6, "e": 9} 。

　　則構造出來的哈夫曼樹以下圖：

　　最後獲得的編碼爲：{"A": "000", "b": "001", "c": "01", "d": "10", "e": "11"} 

3.代碼實現

　　下面就是使用哈夫曼算法來求解編碼問題的主要代碼了：

 1 from Tree.tree import Node
 2 from Queue.queue import PriorityQueue
 3 
 4 
 5 # 哈夫曼樹節點
 6 class HNode(Node):
 7     def __init__(self, value=None, left=None, right=None, weight=None):
 8         super(HNode, self).__init__()
 9         self.value = value
10         self.left = left
11         self.right = right
12         self.weight = weight
13 
14 
15 # 自定義哈夫曼樹
16 class HuffmanTree:
17     def __init__(self):
18         self.root = HNode()
19         self.code = {}
20 
21     def get_leaves(self, node: HNode, code: str):
22         """
23         獲取全部葉節點，對樹中的分支節點向左子節點的路徑標記爲0，向右子節點的路徑標記爲1
24         :param node: 哈夫曼樹的節點
25         :param code: 字符使用的編碼
26         :return:
27         """
28         if not node:
29             return
30         code_ = code  # 由於要分別向左向右探索路徑，因此須要複製一份
31         if node.left:
32             code += "0"
33             self.get_leaves(node.left, code)
34         if node.right:
35             code_ += "1"
36             self.get_leaves(node.right, code_)
37         # 沒有左右子節點，代表是葉子節點
38         if not node.left and not node.right:
39             self.code[node.value] = code
40 
41     def create(self, char_data: dict):
42         """
43         根據傳入的權值列表建立一個哈夫曼樹
44         :param char_data: 字符和其對應頻率的字典
45         """
46         queue = PriorityQueue()
47         # 將節點添加到優先級隊列中
48         for char, weight in char_data.items():
49             node = HNode(value=char, weight=weight)
50             queue.enqueue(node, weight)
51         while queue.size() > 1:
52             node1 = queue.dequeue()
53             node2 = queue.dequeue()
54             new_node = HNode(left=node1, right=node2, weight=node1.weight + node2.weight)
55             queue.enqueue(new_node, new_node.weight)
56         self.root = queue.dequeue()
57 
58 
59 def solution(char_data: dict):
60     """
61     解決哈夫曼編碼問題
62     :param char_data: 字符和其對應頻率的字典
63     :return:
64     """
65     tree = HuffmanTree()
66     tree.create(char_data)
67     tree.get_leaves(tree.root, "")
68     return tree.code