我们知道，二叉查找树相对来说比较容易形成最坏的链表情况，所以前辈们想尽了各种优化策略，包括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相比严格的
平衡二叉树有更少的旋转操作，可以说性能是在”普通二叉树“和”平衡二叉树“之间。
最后是总运行代码，不过这里我就不做测试了。
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 }
时间： 2024-10-11 16:18:52