6天通吃樹結構—— 第三天 Treap樹

本文轉載自查看原文 2012-07-30 02:01 22340 樹結構專題

我們知道，二叉查找樹相對來說比較容易形成最壞的鏈表情況，所以前輩們想盡了各種優化策略，包括AVL，紅黑，以及今天

要講的Treap樹。

Treap樹算是一種簡單的優化策略，這名字大家也能猜到，樹和堆的合體，其實原理比較簡單，在樹中維護一個"優先級“，”優先級“

采用隨機數的方法，但是”優先級“必須滿足根堆的性質，當然是“大根堆”或者“小根堆”都無所謂，比如下面的一棵樹：

從樹中我們可以看到：

①：節點中的key滿足“二叉查找樹”。

②：節點中的“優先級”滿足小根堆。

一：基本操作

1：定義

 1     #region Treap樹節點
 2     /// <summary>
 3     /// Treap樹
 4     /// </summary>
 5     /// <typeparam name="K"></typeparam>
 6     /// <typeparam name="V"></typeparam>
 7     public class TreapNode<K, V>
 8     {
 9         /// <summary>
10         /// 節點元素
11         /// </summary>
12         public K key;
13 
14         /// <summary>
15         /// 優先級（采用隨機數）
16         /// </summary>
17         public int priority;
18 
19         /// <summary>
20         /// 節點中的附加值
21         /// </summary>
22         public HashSet<V> attach = new HashSet<V>();
23 
24         /// <summary>
25         /// 左節點
26         /// </summary>
27         public TreapNode<K, V> left;
28 
29         /// <summary>
30         /// 右節點
31         /// </summary>
32         public TreapNode<K, V> right;
33 
34         public TreapNode() { }
35 
36         public TreapNode(K key, V value, TreapNode<K, V> left, TreapNode<K, V> right)
37         {
38             //KV鍵值對
39             this.key = key;
40             this.priority = new Random(DateTime.Now.Millisecond).Next(0,int.MaxValue);
41             this.attach.Add(value);
42 
43             this.left = left;
44             this.right = right;
45         }
46     }
47     #endregion

節點里面定義了一個priority作為“堆定義”的旋轉因子，因子采用“隨機數“。

2：添加

首先我們知道各個節點的“優先級”是采用隨機數的方法，那么就存在一個問題，當我們插入一個節點后，優先級不滿足“堆定義"的

時候我們該怎么辦，前輩說此時需要旋轉，直到滿足堆定義為止。

旋轉有兩種方式，如果大家玩轉了AVL，那么對Treap中的旋轉的理解輕而易舉。

①：左左情況旋轉

從圖中可以看出，當我們插入“節點12”的時候，此時“堆性質”遭到破壞，必須進行旋轉，我們發現優先級是6<9，所以就要進行

左左情況旋轉，最終也就形成了我們需要的結果。

②：右右情況旋轉

既然理解了”左左情況旋轉“，右右情況也是同樣的道理，優先級中發現“6<9"，進行”右右旋轉“最終達到我們要的效果。

 1         #region 添加操作
 2         /// <summary>
 3         /// 添加操作
 4         /// </summary>
 5         /// <param name="key"></param>
 6         /// <param name="value"></param>
 7         public void Add(K key, V value)
 8         {
 9             node = Add(key, value, node);
10         }
11         #endregion
12 
13         #region 添加操作
14         /// <summary>
15         /// 添加操作
16         /// </summary>
17         /// <param name="key"></param>
18         /// <param name="value"></param>
19         /// <param name="tree"></param>
20         /// <returns></returns>
21         public TreapNode<K, V> Add(K key, V value, TreapNode<K, V> tree)
22         {
23             if (tree == null)
24                 tree = new TreapNode<K, V>(key, value, null, null);
25 
26             //左子樹
27             if (key.CompareTo(tree.key) < 0)
28             {
29                 tree.left = Add(key, value, tree.left);
30 
31                 //根據小根堆性質，需要”左左情況旋轉”
32                 if (tree.left.priority < tree.priority)
33                 {
34                     tree = RotateLL(tree);
35                 }
36             }
37 
38             //右子樹
39             if (key.CompareTo(tree.key) > 0)
40             {
41                 tree.right = Add(key, value, tree.right);
42 
43                 //根據小根堆性質，需要”右右情況旋轉”
44                 if (tree.right.priority < tree.priority)
45                 {
46                     tree = RotateRR(tree);
47                 }
48             }
49 
50             //將value追加到附加值中（也可對應重復元素）
51             if (key.CompareTo(tree.key) == 0)
52                 tree.attach.Add(value);
53 
54             return tree;
55         }
56         #endregion

3:刪除

跟普通的二叉查找樹一樣，刪除結點存在三種情況。

①：葉子結點

跟普通查找樹一樣，直接釋放本節點即可。

②：單孩子結點

跟普通查找樹一樣操作。

③：滿孩子結點

其實在treap中刪除滿孩子結點有兩種方式。

第一種：跟普通的二叉查找樹一樣，找到“右子樹”的最左結點（15），拷貝元素的值，但不拷貝元素的優先級，然后在右子樹中

刪除“結點15”即可，最終效果如下圖。

第二種：將”結點下旋“，直到該節點不是”滿孩子的情況“，該賦null的賦null，該將孩子結點頂上的就頂上，如下圖：

當然從理論上來說，第二種刪除方法更合理，這里我寫的就是第二種情況的代碼。

 1         #region 刪除當前樹中的節點
 2         /// <summary>
 3         /// 刪除當前樹中的節點
 4         /// </summary>
 5         /// <param name="key"></param>
 6         /// <returns></returns>
 7         public void Remove(K key, V value)
 8         {
 9             node = Remove(key, value, node);
10         }
11         #endregion
12 
13         #region 刪除當前樹中的節點
14         /// <summary>
15         /// 刪除當前樹中的節點
16         /// </summary>
17         /// <param name="key"></param>
18         /// <param name="tree"></param>
19         /// <returns></returns>
20         public TreapNode<K, V> Remove(K key, V value, TreapNode<K, V> tree)
21         {
22             if (tree == null)
23                 return null;
24 
25             //左子樹
26             if (key.CompareTo(tree.key) < 0)
27             {
28                 tree.left = Remove(key, value, tree.left);
29             }
30             //右子樹
31             if (key.CompareTo(tree.key) > 0)
32             {
33                 tree.right = Remove(key, value, tree.right);
34             }
35             /*相等的情況*/
36             if (key.CompareTo(tree.key) == 0)
37             {
38                 //判斷里面的HashSet是否有多值
39                 if (tree.attach.Count > 1)
40                 {
41                     //實現惰性刪除
42                     tree.attach.Remove(value);
43                 }
44                 else
45                 {
46                     //有兩個孩子的情況
47                     if (tree.left != null && tree.right != null)
48                     {
49                         //如果左孩子的優先級低就需要“左旋”
50                         if (tree.left.priority < tree.right.priority)
51                         {
52                             tree = RotateLL(tree);
53                         }
54                         else
55                         {
56                             //否則“右旋”
57                             tree = RotateRR(tree);
58                         }
59 
60                         //繼續旋轉
61                         tree = Remove(key, value, tree);
62                     }
63                     else
64                     {
65                         //如果旋轉后已經變成了葉子節點則直接刪除
66                         if (tree == null)
67                             return null;
68 
69                         //最后就是單支樹
70                         tree = tree.left == null ? tree.right : tree.left;
71                     }
72                 }
73             }
74 
75             return tree;
76         }
77         #endregion

4:總結

treap樹在CURD中是期望的logN，由於我們加了”優先級“,所以會出現”鏈表“的情況幾乎不存在，但是他的Add和Remove相比嚴格的

平衡二叉樹有更少的旋轉操作，可以說性能是在”普通二叉樹“和”平衡二叉樹“之間。

最后是總運行代碼，不過這里我就不做測試了。

View Code

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Text;
  5 
  6 namespace DataStruct
  7 {
  8     #region Treap樹節點
  9     /// <summary>
 10     /// Treap樹
 11     /// </summary>
 12     /// <typeparam name="K"></typeparam>
 13     /// <typeparam name="V"></typeparam>
 14     public class TreapNode<K, V>
 15     {
 16         /// <summary>
 17         /// 節點元素
 18         /// </summary>
 19         public K key;
 20 
 21         /// <summary>
 22         /// 優先級（采用隨機數）
 23         /// </summary>
 24         public int priority;
 25 
 26         /// <summary>
 27         /// 節點中的附加值
 28         /// </summary>
 29         public HashSet<V> attach = new HashSet<V>();
 30 
 31         /// <summary>
 32         /// 左節點
 33         /// </summary>
 34         public TreapNode<K, V> left;
 35 
 36         /// <summary>
 37         /// 右節點
 38         /// </summary>
 39         public TreapNode<K, V> right;
 40 
 41         public TreapNode() { }
 42 
 43         public TreapNode(K key, V value, TreapNode<K, V> left, TreapNode<K, V> right)
 44         {
 45             //KV鍵值對
 46             this.key = key;
 47             this.priority = new Random(DateTime.Now.Millisecond).Next(0,int.MaxValue);
 48             this.attach.Add(value);
 49 
 50             this.left = left;
 51             this.right = right;
 52         }
 53     }
 54     #endregion
 55 
 56     public class TreapTree<K, V> where K : IComparable
 57     {
 58         public TreapNode<K, V> node = null;
 59 
 60         #region 添加操作
 61         /// <summary>
 62         /// 添加操作
 63         /// </summary>
 64         /// <param name="key"></param>
 65         /// <param name="value"></param>
 66         public void Add(K key, V value)
 67         {
 68             node = Add(key, value, node);
 69         }
 70         #endregion
 71 
 72         #region 添加操作
 73         /// <summary>
 74         /// 添加操作
 75         /// </summary>
 76         /// <param name="key"></param>
 77         /// <param name="value"></param>
 78         /// <param name="tree"></param>
 79         /// <returns></returns>
 80         public TreapNode<K, V> Add(K key, V value, TreapNode<K, V> tree)
 81         {
 82             if (tree == null)
 83                 tree = new TreapNode<K, V>(key, value, null, null);
 84 
 85             //左子樹
 86             if (key.CompareTo(tree.key) < 0)
 87             {
 88                 tree.left = Add(key, value, tree.left);
 89 
 90                 //根據小根堆性質，需要”左左情況旋轉”
 91                 if (tree.left.priority < tree.priority)
 92                 {
 93                     tree = RotateLL(tree);
 94                 }
 95             }
 96 
 97             //右子樹
 98             if (key.CompareTo(tree.key) > 0)
 99             {
100                 tree.right = Add(key, value, tree.right);
101 
102                 //根據小根堆性質，需要”右右情況旋轉”
103                 if (tree.right.priority < tree.priority)
104                 {
105                     tree = RotateRR(tree);
106                 }
107             }
108 
109             //將value追加到附加值中（也可對應重復元素）
110             if (key.CompareTo(tree.key) == 0)
111                 tree.attach.Add(value);
112 
113             return tree;
114         }
115         #endregion
116 
117         #region 第一種：左左旋轉（單旋轉）
118         /// <summary>
119         /// 第一種：左左旋轉（單旋轉）
120         /// </summary>
121         /// <param name="node"></param>
122         /// <returns></returns>
123         public TreapNode<K, V> RotateLL(TreapNode<K, V> node)
124         {
125             //top：需要作為頂級節點的元素
126             var top = node.left;
127 
128             //先截斷當前節點的左孩子
129             node.left = top.right;
130 
131             //將當前節點作為temp的右孩子
132             top.right = node;
133 
134             return top;
135         }
136         #endregion
137 
138         #region 第二種：右右旋轉（單旋轉）
139         /// <summary>
140         /// 第二種：右右旋轉（單旋轉）
141         /// </summary>
142         /// <param name="node"></param>
143         /// <returns></returns>
144         public TreapNode<K, V> RotateRR(TreapNode<K, V> node)
145         {
146             //top：需要作為頂級節點的元素
147             var top = node.right;
148 
149             //先截斷當前節點的右孩子
150             node.right = top.left;
151 
152             //將當前節點作為temp的右孩子
153             top.left = node;
154 
155             return top;
156         }
157         #endregion
158 
159         #region 樹的指定范圍查找
160         /// <summary>
161         /// 樹的指定范圍查找
162         /// </summary>
163         /// <param name="min"></param>
164         /// <param name="max"></param>
165         /// <returns></returns>
166         public HashSet<V> SearchRange(K min, K max)
167         {
168             HashSet<V> hashSet = new HashSet<V>();
169 
170             hashSet = SearchRange(min, max, hashSet, node);
171 
172             return hashSet;
173         }
174         #endregion
175 
176         #region 樹的指定范圍查找
177         /// <summary>
178         /// 樹的指定范圍查找
179         /// </summary>
180         /// <param name="range1"></param>
181         /// <param name="range2"></param>
182         /// <param name="tree"></param>
183         /// <returns></returns>
184         public HashSet<V> SearchRange(K min, K max, HashSet<V> hashSet, TreapNode<K, V> tree)
185         {
186             if (tree == null)
187                 return hashSet;
188 
189             //遍歷左子樹（尋找下界）
190             if (min.CompareTo(tree.key) < 0)
191                 SearchRange(min, max, hashSet, tree.left);
192 
193             //當前節點是否在選定范圍內
194             if (min.CompareTo(tree.key) <= 0 && max.CompareTo(tree.key) >= 0)
195             {
196                 //等於這種情況
197                 foreach (var item in tree.attach)
198                     hashSet.Add(item);
199             }
200 
201             //遍歷右子樹（兩種情況：①:找min的下限 ②：必須在Max范圍之內）
202             if (min.CompareTo(tree.key) > 0 || max.CompareTo(tree.key) > 0)
203                 SearchRange(min, max, hashSet, tree.right);
204 
205             return hashSet;
206         }
207         #endregion
208 
209         #region 找到當前樹的最小節點
210         /// <summary>
211         /// 找到當前樹的最小節點
212         /// </summary>
213         /// <returns></returns>
214         public TreapNode<K, V> FindMin()
215         {
216             return FindMin(node);
217         }
218         #endregion
219 
220         #region 找到當前樹的最小節點
221         /// <summary>
222         /// 找到當前樹的最小節點
223         /// </summary>
224         /// <param name="tree"></param>
225         /// <returns></returns>
226         public TreapNode<K, V> FindMin(TreapNode<K, V> tree)
227         {
228             if (tree == null)
229                 return null;
230 
231             if (tree.left == null)
232                 return tree;
233 
234             return FindMin(tree.left);
235         }
236         #endregion
237 
238         #region 找到當前樹的最大節點
239         /// <summary>
240         /// 找到當前樹的最大節點
241         /// </summary>
242         /// <returns></returns>
243         public TreapNode<K, V> FindMax()
244         {
245             return FindMin(node);
246         }
247         #endregion
248 
249         #region 找到當前樹的最大節點
250         /// <summary>
251         /// 找到當前樹的最大節點
252         /// </summary>
253         /// <param name="tree"></param>
254         /// <returns></returns>
255         public TreapNode<K, V> FindMax(TreapNode<K, V> tree)
256         {
257             if (tree == null)
258                 return null;
259 
260             if (tree.right == null)
261                 return tree;
262 
263             return FindMax(tree.right);
264         }
265         #endregion
266 
267         #region 刪除當前樹中的節點
268         /// <summary>
269         /// 刪除當前樹中的節點
270         /// </summary>
271         /// <param name="key"></param>
272         /// <returns></returns>
273         public void Remove(K key, V value)
274         {
275             node = Remove(key, value, node);
276         }
277         #endregion
278 
279         #region 刪除當前樹中的節點
280         /// <summary>
281         /// 刪除當前樹中的節點
282         /// </summary>
283         /// <param name="key"></param>
284         /// <param name="tree"></param>
285         /// <returns></returns>
286         public TreapNode<K, V> Remove(K key, V value, TreapNode<K, V> tree)
287         {
288             if (tree == null)
289                 return null;
290 
291             //左子樹
292             if (key.CompareTo(tree.key) < 0)
293             {
294                 tree.left = Remove(key, value, tree.left);
295             }
296             //右子樹
297             if (key.CompareTo(tree.key) > 0)
298             {
299                 tree.right = Remove(key, value, tree.right);
300             }
301             /*相等的情況*/
302             if (key.CompareTo(tree.key) == 0)
303             {
304                 //判斷里面的HashSet是否有多值
305                 if (tree.attach.Count > 1)
306                 {
307                     //實現惰性刪除
308                     tree.attach.Remove(value);
309                 }
310                 else
311                 {
312                     //有兩個孩子的情況
313                     if (tree.left != null && tree.right != null)
314                     {
315                         //如果左孩子的優先級低就需要“左旋”
316                         if (tree.left.priority < tree.right.priority)
317                         {
318                             tree = RotateLL(tree);
319                         }
320                         else
321                         {
322                             //否則“右旋”
323                             tree = RotateRR(tree);
324                         }
325 
326                         //繼續旋轉
327                         tree = Remove(key, value, tree);
328                     }
329                     else
330                     {
331                         //如果旋轉后已經變成了葉子節點則直接刪除
332                         if (tree == null)
333                             return null;
334 
335                         //最后就是單支樹
336                         tree = tree.left == null ? tree.right : tree.left;
337                     }
338                 }
339             }
340 
341             return tree;
342         }
343         #endregion
344     }
345 }

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 6天通吃樹結構—— 第四天伸展樹 6天通吃樹結構—— 第五天 Trie樹 6天通吃樹結構—— 第一天二叉查找樹 6天通吃樹結構—— 第二天平衡二叉樹九天學會Java，第三天，選擇結構實習之第三天蘇州（第三天） 8天入門wpf—— 第三天樣式學習python第三天 C語言第三天