?

?? 今天說下最后一種樹，大家可否知道，文件壓縮程序里面的核心結構，核心算法是什么？或許你知道，他就運用了赫夫曼樹。

聽說赫夫曼勝過了他的導師，被認為”青出于藍而勝于藍“，這句話也是我比較欣賞的，嘻嘻。

?

一? 概念

????了解”赫夫曼樹“之前，幾個必須要知道的專業名詞可要熟練記住啊。

?

??? 1： 結點的權

??????????? “權”就相當于“重要度”，我們形象的用一個具體的數字來表示，然后通過數字的大小來決定誰重要，誰不重要。

????2： 路徑

???????????? 樹中從“一個結點"到“另一個結點“之間的分支。

??? 3： 路徑長度

???????????? 一個路徑上的分支數量。

????4： 樹的路徑長度

???????????? 從樹的根節點到每個節點的路徑長度之和。

??? 5： 節點的帶權路徑路勁長度

?????????????其實也就是該節點到根結點的路徑長度*該節點的權。

????6:???樹的帶權路徑長度

???????????? 樹中各個葉節點的路徑長度*該葉節點的權的和，常用WPL(Weight Path Length)表示。

?

二： 構建赫夫曼樹

??????? 上面說了那么多，肯定是為下面做鋪墊，這里說赫夫曼樹，肯定是要說赫夫曼樹咋好咋好，赫夫曼樹是一種最優二叉樹,

?????????因為他的WPL是最短的，何以見得？我們可以上圖說話。

???

現在我們做一個WPL的對比：

圖A: WPL= 5*2 + 7*2 +2*2+13*2=54

圖B：WPL=5*3+2*3+7*2+13*1=48

?

我們對比一下，圖B的WPL最短的，地球人已不能阻止WPL還能比“圖B”的小，所以，“圖B"就是一顆赫夫曼樹，那么大家肯定

要問，如何構建一顆赫夫曼樹，還是上圖說話。

?

第一步： 我們將所有的節點都作為獨根結點。

第二步: ? 我們將最小的C和A組建為一個新的二叉樹，權值為左右結點之和。

第三步： 將上一步組建的新節點加入到剩下的節點中，排除上一步組建過的左右子樹，我們選中B組建新的二叉樹，然后取權值。

第四步： 同上。

?

三： 赫夫曼編碼

? ? ? 大家都知道，字符，漢字，數字在計算機中都是以0，1來表示的，相應的存儲都是有一套編碼方案來支撐的，比如ASC碼。

?這樣才能在"編碼“和”解碼“的過程中不會成為亂碼，但是ASC碼不理想的地方就是等長的，其實我們都想用較少的空間來存儲

更多的東西，那么我們就要采用”不等長”的編碼方案來存儲，那么“何為不等長呢“？其實也就是出現次數比較多的字符我們采用短編碼，

出現次數較少的字符我們采用長編碼，恰好，“赫夫曼編碼“就是不等長的編碼。

? ? 這里大家只要掌握赫夫曼樹的編碼規則：左子樹為0，右子樹為1，對應的編碼后的規則是：從根節點到子節點

A: 111

B: 10

C: 110

D: 0

?

四： 實現

? ? ? 不知道大家懂了沒有，不懂的話多看幾篇，下面說下赫夫曼的具體實現。

? ? ? ? ?第一步：構建赫夫曼樹。

? ? ? ? ?第二步：對赫夫曼樹進行編碼。

? ? ? ? ?第三步：壓縮操作。

? ? ? ? ?第四步：解壓操作。

?

1：首先看下赫夫曼樹的結構，這里字段的含義就不解釋了。

1 #region 赫夫曼樹結構
2 /// <summary>
3 /// 赫夫曼樹結構
4 /// </summary>
5 public class HuffmanTree
6 {
7 public int weight { get; set; }
8
9 public int parent { get; set; }
10
11 public int left { get; set; }
12
13 public int right { get; set; }
14 }
15 #endregion

?

2： 創建赫夫曼樹，原理在上面已經解釋過了，就是一步一步的向上搭建，這里要注意的二個性質定理：

? ? ? ? ?當葉子節點為N個，則需要N-1步就能搭建赫夫曼樹。

? ? ? ? ?當葉子節點為N個，則赫夫曼樹的節點總數為:(2*N)-1個。

1 #region 赫夫曼樹的創建
2 /// <summary>
3 /// 赫夫曼樹的創建
4 /// </summary>
5 /// <param name="huffman">赫夫曼樹</param>
6 /// <param name="leafNum">葉子節點</param>
7 /// <param name="weight">節點權重</param>
8 public HuffmanTree[] CreateTree(HuffmanTree[] huffman, int leafNum, int[] weight)
9 {
10 //赫夫曼樹的節點總數
11 int huffmanNode = 2 * leafNum - 1;
12
13 //初始化節點，賦予葉子節點值
14 for (int i = 0; i < huffmanNode; i++)
15 {
16 if (i < leafNum)
17 {
18 huffman[i].weight = weight[i];
19 }
20 }
21
22 //這里面也要注意，4個節點，其實只要3步就可以構造赫夫曼樹
23 for (int i = leafNum; i < huffmanNode; i++)
24 {
25 int minIndex1;
26 int minIndex2;
27 SelectNode(huffman, i, out minIndex1, out minIndex2);
28
29 //最后得出minIndex1和minindex2中實體的weight最小
30 huffman[minIndex1].parent = i;
31 huffman[minIndex2].parent = i;
32
33 huffman[i].left = minIndex1;
34 huffman[i].right = minIndex2;
35
36 huffman[i].weight = huffman[minIndex1].weight + huffman[minIndex2].weight;
37 }
38
39 return huffman;
40 }
41 #endregion
42
43 #region 選出葉子節點中最小的二個節點
44 /// <summary>
45 /// 選出葉子節點中最小的二個節點
46 /// </summary>
47 /// <param name="huffman"></param>
48 /// <param name="searchNodes">要查找的結點數</param>
49 /// <param name="minIndex1"></param>
50 /// <param name="minIndex2"></param>
51 public void SelectNode(HuffmanTree[] huffman, int searchNodes, out int minIndex1, out int minIndex2)
52 {
53 HuffmanTree minNode1 = null;
54
55 HuffmanTree minNode2 = null;
56
57 //最小節點在赫夫曼樹中的下標
58 minIndex1 = minIndex2 = 0;
59
60 //查找范圍
61 for (int i = 0; i < searchNodes; i++)
62 {
63 ///只有獨根樹才能進入查找范圍
64 if (huffman[i].parent == 0)
65 {
66 //如果為null，則認為當前實體為最小
67 if (minNode1 == null)
68 {
69 minIndex1 = i;
70
71 minNode1 = huffman[i];
72
73 continue;
74 }
75
76 //如果為null，則認為當前實體為最小
77 if (minNode2 == null)
78 {
79 minIndex2 = i;
80
81 minNode2 = huffman[i];
82
83 //交換一個位置，保證minIndex1為最小，為后面判斷做準備
84 if (minNode1.weight > minNode2.weight)
85 {
86 //節點交換
87 var temp = minNode1;
88 minNode1 = minNode2;
89 minNode2 = temp;
90
91 //下標交換
92 var tempIndex = minIndex1;
93 minIndex1 = minIndex2;
94 minIndex2 = tempIndex;
95
96 continue;
97 }
98 }
99 if (minNode1 != null && minNode2 != null)
100 {
101 if (huffman[i].weight <= minNode1.weight)
102 {
103 //將min1臨時轉存給min2
104 minNode2 = minNode1;
105 minNode1 = huffman[i];
106
107 //記錄在數組中的下標
108 minIndex2 = minIndex1;
109 minIndex1 = i;
110 }
111 else
112 {
113 if (huffman[i].weight < minNode2.weight)
114 {
115 minNode2 = huffman[i];
116
117 minIndex2 = i;
118 }
119 }
120 }
121 }
122 }
123 }
124 #endregion

3:對哈夫曼樹進行編碼操作，形成一套“模板”，效果跟ASC模板一樣，不過一個是不等長，一個是等長。

1 #region 赫夫曼編碼
2 /// <summary>
3 /// 赫夫曼編碼
4 /// </summary>
5 /// <param name="huffman"></param>
6 /// <param name="leafNum"></param>
7 /// <param name="huffmanCode"></param>
8 public string[] HuffmanCoding(HuffmanTree[] huffman, int leafNum)
9 {
10 int current = 0;
11
12 int parent = 0;
13
14 string[] huffmanCode = new string[leafNum];
15
16 //四個葉子節點的循環
17 for (int i = 0; i < leafNum; i++)
18 {
19 //單個字符的編碼串
20 string codeTemp = string.Empty;
21
22 current = i;
23
24 //第一次獲取最左節點
25 parent = huffman[current].parent;
26
27 while (parent != 0)
28 {
29 //如果父節點的左子樹等于當前節點就標記為0
30 if (current == huffman[parent].left)
31 codeTemp += "0";
32 else
33 codeTemp += "1";
34
35 current = parent;
36 parent = huffman[parent].parent;
37 }
38
39 huffmanCode[i] = new string(codeTemp.Reverse().ToArray());
40 }
41 return huffmanCode;
42 }
43 #endregion

4：模板生成好了，我們就要對指定的測試數據進行壓縮處理

1 #region 對指定字符進行壓縮
2 /// <summary>
3 /// 對指定字符進行壓縮
4 /// </summary>
5 /// <param name="huffmanCode"></param>
6 /// <param name="alphabet"></param>
7 /// <param name="test"></param>
8 public string Encode(string[] huffmanCode, string[] alphabet, string test)
9 {
10 //返回的0,1代碼
11 string encodeStr = string.Empty;
12
13 //對每個字符進行編碼
14 for (int i = 0; i < test.Length; i++)
15 {
16 //在模版里面查找
17 for (int j = 0; j < alphabet.Length; j++)
18 {
19 if (test[i].ToString() == alphabet[j])
20 {
21 encodeStr += huffmanCode[j];
22 }
23 }
24 }
25
26 return encodeStr;
27 }
28 #endregion

?

5： 最后也就是對壓縮的數據進行還原操作。

1 #region 對指定的二進制進行解壓
2 /// <summary>
3 /// 對指定的二進制進行解壓
4 /// </summary>
5 /// <param name="huffman"></param>
6 /// <param name="leafNum"></param>
7 /// <param name="alphabet"></param>
8 /// <param name="test"></param>
9 /// <returns></returns>
10 public string Decode(HuffmanTree[] huffman, int huffmanNodes, string[] alphabet, string test)
11 {
12 string decodeStr = string.Empty;
13
14 //所有要解碼的字符
15 for (int i = 0; i < test.Length; )
16 {
17 int j = 0;
18 //赫夫曼樹結構模板(用于循環的解碼單個字符)
19 for (j = huffmanNodes - 1; (huffman[j].left != 0 || huffman[j].right != 0); )
20 {
21 if (test[i].ToString() == "0")
22 {
23 j = huffman[j].left;
24 }
25 if (test[i].ToString() == "1")
26 {
27 j = huffman[j].right;
28 }
29 i++;
30 }
31 decodeStr += alphabet[j];
32 }
33 return decodeStr;
34 }
35
36 #endregion

?

最后上一下總的運行代碼

View Code 1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5
6 namespace HuffmanTree
7 {
8 class Program
9 {
10 static void Main(string[] args)
11 {
12 //有四個葉節點
13 int leafNum = 4;
14
15 //赫夫曼樹中的節點總數
16 int huffmanNodes = 2 * leafNum - 1;
17
18 //各節點的權值
19 int[] weight = { 5, 7, 2, 13 };
20
21 string[] alphabet = { "A", "B", "C", "D" };
22
23 string testCode = "DBDBDABDCDADBDADBDADACDBDBD";
24
25 //赫夫曼樹用數組來保存，每個赫夫曼都作為一個實體存在
26 HuffmanTree[] huffman = new HuffmanTree[huffmanNodes].Select(i => new HuffmanTree() { }).ToArray();
27
28 HuffmanTreeManager manager = new HuffmanTreeManager();
29
30 manager.CreateTree(huffman, leafNum, weight);
31
32 string[] huffmanCode = manager.HuffmanCoding(huffman, leafNum);
33
34 for (int i = 0; i < leafNum; i++)
35 {
36 Console.WriteLine("字符：{0}，權重:{1},編碼為:{2}", alphabet[i], huffman[i].weight, huffmanCode[i]);
37 }
38
39 Console.WriteLine("原始的字符串為：" + testCode);
40
41 string encode = manager.Encode(huffmanCode, alphabet, testCode);
42
43 Console.WriteLine("被編碼的字符串為：" + encode);
44
45 string decode = manager.Decode(huffman, huffmanNodes, alphabet, encode);
46
47 Console.WriteLine("解碼后的字符串為：" + decode);
48 }
49 }
50
51 #region 赫夫曼樹結構
52 /// <summary>
53 /// 赫夫曼樹結構
54 /// </summary>
55 public class HuffmanTree
56 {
57 public int weight { get; set; }
58
59 public int parent { get; set; }
60
61 public int left { get; set; }
62
63 public int right { get; set; }
64 }
65 #endregion
66
67 /// <summary>
68 /// 赫夫曼樹的操作類
69 /// </summary>
70 public class HuffmanTreeManager
71 {
72 #region 赫夫曼樹的創建
73 /// <summary>
74 /// 赫夫曼樹的創建
75 /// </summary>
76 /// <param name="huffman">赫夫曼樹</param>
77 /// <param name="leafNum">葉子節點</param>
78 /// <param name="weight">節點權重</param>
79 public HuffmanTree[] CreateTree(HuffmanTree[] huffman, int leafNum, int[] weight)
80 {
81 //赫夫曼樹的節點總數
82 int huffmanNode = 2 * leafNum - 1;
83
84 //初始化節點，賦予葉子節點值
85 for (int i = 0; i < huffmanNode; i++)
86 {
87 if (i < leafNum)
88 {
89 huffman[i].weight = weight[i];
90 }
91 }
92
93 //這里面也要注意，4個節點，其實只要3步就可以構造赫夫曼樹
94 for (int i = leafNum; i < huffmanNode; i++)
95 {
96 int minIndex1;
97 int minIndex2;
98 SelectNode(huffman, i, out minIndex1, out minIndex2);
99
100 //最后得出minIndex1和minindex2中實體的weight最小
101 huffman[minIndex1].parent = i;
102 huffman[minIndex2].parent = i;
103
104 huffman[i].left = minIndex1;
105 huffman[i].right = minIndex2;
106
107 huffman[i].weight = huffman[minIndex1].weight + huffman[minIndex2].weight;
108 }
109
110 return huffman;
111 }
112 #endregion
113
114 #region 選出葉子節點中最小的二個節點
115 /// <summary>
116 /// 選出葉子節點中最小的二個節點
117 /// </summary>
118 /// <param name="huffman"></param>
119 /// <param name="searchNodes">要查找的結點數</param>
120 /// <param name="minIndex1"></param>
121 /// <param name="minIndex2"></param>
122 public void SelectNode(HuffmanTree[] huffman, int searchNodes, out int minIndex1, out int minIndex2)
123 {
124 HuffmanTree minNode1 = null;
125
126 HuffmanTree minNode2 = null;
127
128 //最小節點在赫夫曼樹中的下標
129 minIndex1 = minIndex2 = 0;
130
131 //查找范圍
132 for (int i = 0; i < searchNodes; i++)
133 {
134 ///只有獨根樹才能進入查找范圍
135 if (huffman[i].parent == 0)
136 {
137 //如果為null，則認為當前實體為最小
138 if (minNode1 == null)
139 {
140 minIndex1 = i;
141
142 minNode1 = huffman[i];
143
144 continue;
145 }
146
147 //如果為null，則認為當前實體為最小
148 if (minNode2 == null)
149 {
150 minIndex2 = i;
151
152 minNode2 = huffman[i];
153
154 //交換一個位置，保證minIndex1為最小，為后面判斷做準備
155 if (minNode1.weight > minNode2.weight)
156 {
157 //節點交換
158 var temp = minNode1;
159 minNode1 = minNode2;
160 minNode2 = temp;
161
162 //下標交換
163 var tempIndex = minIndex1;
164 minIndex1 = minIndex2;
165 minIndex2 = tempIndex;
166
167 continue;
168 }
169 }
170 if (minNode1 != null && minNode2 != null)
171 {
172 if (huffman[i].weight <= minNode1.weight)
173 {
174 //將min1臨時轉存給min2
175 minNode2 = minNode1;
176 minNode1 = huffman[i];
177
178 //記錄在數組中的下標
179 minIndex2 = minIndex1;
180 minIndex1 = i;
181 }
182 else
183 {
184 if (huffman[i].weight < minNode2.weight)
185 {
186 minNode2 = huffman[i];
187
188 minIndex2 = i;
189 }
190 }
191 }
192 }
193 }
194 }
195 #endregion
196
197 #region 赫夫曼編碼
198 /// <summary>
199 /// 赫夫曼編碼
200 /// </summary>
201 /// <param name="huffman"></param>
202 /// <param name="leafNum"></param>
203 /// <param name="huffmanCode"></param>
204 public string[] HuffmanCoding(HuffmanTree[] huffman, int leafNum)
205 {
206 int current = 0;
207
208 int parent = 0;
209
210 string[] huffmanCode = new string[leafNum];
211
212 //四個葉子節點的循環
213 for (int i = 0; i < leafNum; i++)
214 {
215 //單個字符的編碼串
216 string codeTemp = string.Empty;
217
218 current = i;
219
220 //第一次獲取最左節點
221 parent = huffman[current].parent;
222
223 while (parent != 0)
224 {
225 //如果父節點的左子樹等于當前節點就標記為0
226 if (current == huffman[parent].left)
227 codeTemp += "0";
228 else
229 codeTemp += "1";
230
231 current = parent;
232 parent = huffman[parent].parent;
233 }
234
235 huffmanCode[i] = new string(codeTemp.Reverse().ToArray());
236 }
237 return huffmanCode;
238 }
239 #endregion
240
241 #region 對指定字符進行壓縮
242 /// <summary>
243 /// 對指定字符進行壓縮
244 /// </summary>
245 /// <param name="huffmanCode"></param>
246 /// <param name="alphabet"></param>
247 /// <param name="test"></param>
248 public string Encode(string[] huffmanCode, string[] alphabet, string test)
249 {
250 //返回的0,1代碼
251 string encodeStr = string.Empty;
252
253 //對每個字符進行編碼
254 for (int i = 0; i < test.Length; i++)
255 {
256 //在模版里面查找
257 for (int j = 0; j < alphabet.Length; j++)
258 {
259 if (test[i].ToString() == alphabet[j])
260 {
261 encodeStr += huffmanCode[j];
262 }
263 }
264 }
265
266 return encodeStr;
267 }
268 #endregion
269
270 #region 對指定的二進制進行解壓
271 /// <summary>
272 /// 對指定的二進制進行解壓
273 /// </summary>
274 /// <param name="huffman"></param>
275 /// <param name="leafNum"></param>
276 /// <param name="alphabet"></param>
277 /// <param name="test"></param>
278 /// <returns></returns>
279 public string Decode(HuffmanTree[] huffman, int huffmanNodes, string[] alphabet, string test)
280 {
281 string decodeStr = string.Empty;
282
283 //所有要解碼的字符
284 for (int i = 0; i < test.Length; )
285 {
286 int j = 0;
287 //赫夫曼樹結構模板(用于循環的解碼單個字符)
288 for (j = huffmanNodes - 1; (huffman[j].left != 0 || huffman[j].right != 0); )
289 {
290 if (test[i].ToString() == "0")
291 {
292 j = huffman[j].left;
293 }
294 if (test[i].ToString() == "1")
295 {
296 j = huffman[j].right;
297 }
298 i++;
299 }
300 decodeStr += alphabet[j];
301 }
302 return decodeStr;
303 }
304
305 #endregion
306 }
307 }

?

總結

以上是生活随笔為你收集整理的算法系列15天速成——第十三天 树操作【下】的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。