BST, AVL Tree 和 Splay Tree 的实现

Posted 2020-10-29 lyf520

一、定义。

1.1 BST

　　二叉搜索树，也称有序二叉树,排序二叉树，是指一棵空树或者具有下列性质的二叉树：

　　① 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

　　② 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

　　③ 任意节点的左、右子树也分别为二叉查找树。

　　④ 没有键值相等的节点。

1.2 AVL Tree

　　平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉树：它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树。

　　平衡因子(bf)：结点的左子树的深度减去右子树的深度。

　　保持平衡是依赖于旋转操作，分为LL, RR, LR, RL四种情况。

　　LL单旋即右旋。

　　

1.3 Splay Tree

　　伸展树的出发点是这样的：考虑到局部性原理（刚被访问的内容下次可能仍会被访问，查找次数多的内容可能下一次会被访问），为了使整个查找时间更小，被查频率高的那些节点应当经常处于靠近树根的位置。这样，很容易得想到以下这个方案：每次查找节点之后对树进行重构，把被查找的节点搬移到树根，这种自调整形式的二叉查找树就是伸展树。每次对伸展树进行操作后，它均会通过旋转的方法把被访问节点旋转到树根的位置。

　　为了将当前被访问节点旋转到树根，我们通常将节点自底向上旋转，直至该节点成为树根为止。“旋转”的巧妙之处就是在不打乱数列中数据大小关系（指中序遍历结果是全序的）情况下，所有基本操作的平摊复杂度仍为O（log n）。

　　伸展树主要有三种旋转操作，分别为单旋转，一字形旋转和之字形旋转。为了便于解释，我们假设当前被访问节点为X，X的父亲节点为Y（如果X的父亲节点存在），X的祖父节点为Z（如果X的祖父节点存在）。这里的单旋与之字形旋转与AVL树是一致的，因此这里只列出Zig-Zig。

　　

 

　　Splay操作可以自底向上也可以自顶向下，我只实现了自底向上的算法，自顶向下以后有机会再补充，因为每次操作都需要把操作的结点翻转到根，所以用Zig-Zig代替单旋，每次上升两层，如果根节点恰好是父节点，则此时只需要一次单旋。

 

二、复杂度分析。

　　AVL无论是在顺序逆序或者随机插入删除的情况下效果都不错，而Splay在按照顺序或者逆序的情况下效果比较好，因为预测准确，而随机则无法预测，所做的Splay操作都是多余的，所以比较慢，AVL 和 Splay 哪个更合适需要具体情况具体分析。

2.1 BST

Algorithm		Average	Worst case
Space		O(n)	O(n)
Search		O(log n)	O(n)
Insert		O(log n)	O(n)
Delete		O(log n)	O(n)

2.2 AVL Tree

Algorithm		Average	Worst case
Space		O(n)	O(n)
Search		O(log n)	O(log n)
Insert		O(log n)	O(log n)
Delete		O(log n)	O(log n)

2.3 Splay Tree

Algorithm		Average	Worst case
Space		O(n)	O(n)
Search		O(log n)	amortized O(log n)
Insert		O(log n)	amortized O(log n)
Delete		O(log n)	amortized O(log n)

 

三、实现。

　　水平有限，写的比较啰嗦，见谅。

  1 #include <iostream>
  2 using namespace std;
  3 // Binery Search Tree Node
  4 class BSTreeNode {
  5 public:
  6     int data;
  7     BSTreeNode* leftChild;
  8     BSTreeNode* rightChild;
  9     BSTreeNode(int value): data(value), leftChild(NULL), rightChild(NULL){}
 10 };
 11 // AVL Tree Node
 12 class AVLTreeNode {
 13 public:
 14     int data;
 15     // The height of node
 16     int height;
 17     AVLTreeNode* leftChild;
 18     AVLTreeNode* rightChild;
 19     AVLTreeNode(int value): data(value), height(0), leftChild(NULL), rightChild(NULL){}
 20 };
 21 // Splay Tree Node
 22 class SplayTreeNode {
 23 public:
 24     int data;
 25     // The pointer to parent
 26     SplayTreeNode* parent;
 27     SplayTreeNode* leftChild;
 28     SplayTreeNode* rightChild;
 29     SplayTreeNode(int value): data(value), parent(NULL), leftChild(NULL), rightChild(NULL){}
 30 };
 31 // Preorder traversal
 32 void previsit(SplayTreeNode* T){
 33     if(T){
 34         cout<<T->data<<‘ ‘;
 35         previsit(T->leftChild);
 36         previsit(T->rightChild);
 37     }
 38 
 39 }
 40 // Preorder traversal
 41 void previsit(BSTreeNode* T){
 42     if(T!=NULL){
 43         cout<<T->data<<‘ ‘;
 44         previsit(T->leftChild);
 45         previsit(T->rightChild);
 46     }
 47 }
 48 // Preorder traversal
 49 void previsit(AVLTreeNode* T){
 50     if(T){
 51             cout<<T->data<<‘ ‘;
 52             previsit(T->leftChild);
 53             previsit(T->rightChild);
 54     }
 55 
 56 }
 57 // Find the minimun element
 58 BSTreeNode* BSTreeFindMin(BSTreeNode* T) {
 59     if (T == NULL) {
 60         return NULL;
 61     } else if (T->leftChild == NULL) {
 62         return T;
 63     } else {
 64         return BSTreeFindMin(T->leftChild);
 65     }
 66 }
 67 // Insert operation of Binery Search Tree
 68 BSTreeNode* BSTreeInsert(int value, BSTreeNode* T) {
 69     if (T == NULL) {
 70         T = new BSTreeNode(value);
 71     } else {
 72         // If value is smaller than element
 73         if (value < T->data) {
 74             T->leftChild = BSTreeInsert(value, T->leftChild);
 75         } 
 76         // If value is larger than element
 77         else if (value > T->data) {
 78             T->rightChild = BSTreeInsert(value, T->rightChild);
 79         }
 80     }
 81     return T;
 82 }
 83 // Delete operation of Binery Search Tree
 84 BSTreeNode* BSTreeDelete(int value, BSTreeNode* T) {
 85     if (T == NULL) {
 86         return NULL;
 87     } 
 88     // If value is smaller than element
 89     else if (value < T->data) {
 90         T->leftChild = BSTreeDelete(value, T->leftChild);
 91     } 
 92     // If value is larger than element
 93     else if (value > T->data) {
 94         T->rightChild = BSTreeDelete(value, T->rightChild);
 95     } 
 96     // If value is equal to element
 97     else {
 98         if (T->leftChild && T->rightChild) {
 99             // Two children
100             BSTreeNode* tmp = BSTreeFindMin(T->rightChild);
101             T->data = tmp->data;
102             //delete tmp;
103             T->rightChild = BSTreeDelete(T->data, T->rightChild);
104         } else {
105             // One or no child
106             if (T->leftChild) {
107                 T = T->leftChild;
108             } else if (T->rightChild) {
109                 T = T->rightChild;
110             } else {
111                 T = NULL;
112             }
113         }
114     }
115     return T;
116 }
117 // Get the height of AVL Tree
118 int getHeight(AVLTreeNode* T) {
119     if (T == NULL) {
120         return -1;
121     } else {
122         return T->height;
123     }
124 }
125 // Get the larger one element
126 int Max(int x, int y) {
127     return (x > y) ? x : y;
128 }
129 // LL Rotation
130 AVLTreeNode* SingleRotateWithLeft(AVLTreeNode* K2) {
131     AVLTreeNode* K1;
132 
133     K1 = K2->leftChild;
134     K2->leftChild = K1->rightChild;
135     K1->rightChild = K2;
136 
137     // Update the height of node
138     K2->height = Max(getHeight(K2->leftChild), getHeight(K2->rightChild)) + 1;
139     K1->height = Max(getHeight(K1->leftChild), getHeight(K1->rightChild)) + 1;
140     return K1;
141 }
142 // RR Rotation
143 AVLTreeNode* SingleRotateWithRight(AVLTreeNode* K2) {
144     AVLTreeNode* K1;
145 
146     K1 = K2->rightChild;
147     K2->rightChild = K1->leftChild;
148     K1->leftChild = K2;
149 
150     // Update the height of node
151     K2->height = Max(getHeight(K2->leftChild), getHeight(K2->rightChild)) + 1;
152     K1->height = Max(getHeight(K1->leftChild), getHeight(K1->rightChild)) + 1;
153     return K1;
154 }
155 // LR Rotation
156 AVLTreeNode* DoubleRotateWithLeft(AVLTreeNode* K3) {
157     K3->leftChild = SingleRotateWithRight(K3->leftChild);
158     return SingleRotateWithLeft(K3);
159 }
160 // RL Rotation
161 AVLTreeNode* DoubleRotateWithRight(AVLTreeNode* K3) {
162     K3->rightChild = SingleRotateWithLeft(K3->rightChild);
163     return SingleRotateWithRight(K3);
164 }
165 // Find the minimum element
166 AVLTreeNode* AVLTreeFindMin(AVLTreeNode* T) {
167     if (T == NULL) {
168         return NULL;
169     } else if (T->leftChild == NULL) {
170         return T;
171     } else {
172         return AVLTreeFindMin(T->leftChild);
173     }
174 }
175 // Insert operation of AVL Tree
176 AVLTreeNode* AVLTreeInsert(int value, AVLTreeNode* T) {
177     if (T == NULL) {
178         T = new AVLTreeNode(value);
179         return T;
180     } else {
181         // If value is smaller than element
182         if (value < T->data) {
183             T->leftChild = AVLTreeInsert(value, T->leftChild);
184             // If the balance is broken
185             if (getHeight(T->leftChild) - getHeight(T->rightChild) == 2) {
186                 if (value < T->leftChild->data) {
187                     // LL Rotation
188                     T = SingleRotateWithLeft(T);
189                 } else {
190                     // LR Rotation
191                     T = DoubleRotateWithLeft(T);
192                 }
193             }
194         } 
195         // If value is larger than element
196         else if (value > T->data) {
197             T->rightChild = AVLTreeInsert(value, T->rightChild);
198             // If the balance is broken
199             if (getHeight(T->rightChild) - getHeight(T->leftChild) == 2) {
200                 if (value > T->rightChild->data) {
201                     // RR Rotation
202                     T = SingleRotateWithRight(T);
203                 } else {
204                     // RL Rotation
205                     T = DoubleRotateWithRight(T);
206                 }
207             }
208         }
209 
210         // Update the height of node
211         if (T) {
212             T->height = Max(getHeight(T->leftChild), getHeight(T->rightChild)) + 1;
213         }
214         return T;
215     }
216 }
217 // Delete operation of AVL Tree
218 AVLTreeNode* AVLTreeDelete(int value, AVLTreeNode* T) {
219     if (T == NULL) {
220         return NULL;
221     } else {
222         // If value is smaller than element
223         if (value < T->data) {
224             T->leftChild = AVLTreeDelete(value, T->leftChild);
225             // If the balance is broken
226             if (getHeight(T->rightChild) - getHeight(T->leftChild) == 2) {
227                 // Delete is similar to insert
228                 // We can assume the unbalance is caused by insert an element
229                 if (getHeight(T->rightChild->rightChild) >= getHeight(T->rightChild->leftChild)) {
230                     // RR Rotation
231                     T = SingleRotateWithRight(T);
232                 } else {
233                     // RL Rotation
234                     T = DoubleRotateWithRight(T);
235                 }
236             }
237         } 
238         // If value is larger than element
239         else if (value > T->data) {
240             T->rightChild = AVLTreeDelete(value, T->rightChild);
241             // If the balance is broken
242             if (getHeight(T->leftChild) - getHeight(T->rightChild) == 2) {
243                 // Delete is similar to insert
244                 // We can assume the unbalance is caused by insert an element
245                 if (getHeight(T->leftChild->leftChild) >= getHeight(T->leftChild->rightChild)) {
246                     // LL Rotation
247                     T = SingleRotateWithLeft(T);
248                 } else {
249                     // LR Rotation
250                     T = DoubleRotateWithLeft(T);
251                 }
252             }
253         } 
254         // If value is equal to element
255         else {
256             if (T->leftChild && T->rightChild) {
257                 // Two children
258                 AVLTreeNode* tmp = AVLTreeFindMin(T->rightChild);
259                 T->data = tmp->data;
260                 //delete tmp;
261                 T->rightChild = AVLTreeDelete(T->data, T->rightChild);
262             } else {
263                 // One or no child
264                 if (T->leftChild) {
265                     T = T->leftChild;
266                 } else if (T->rightChild) {
267                     T = T->rightChild;
268                 } else {
269                     T = NULL;
270                 }
271             }
272         }
273     }
274 
275     // Update the height of node
276     if (T) {
277         T->height = Max(getHeight(T->leftChild), getHeight(T->rightChild)) + 1;
278     }
279     return T;
280 }
281 // LL Rotation of Splay Tree
282 SplayTreeNode* SplaySingleRotateWithLeft(SplayTreeNode* K2) {
283     // It is similar to AVL Tree
284     // But we must update the parent of node
285     SplayTreeNode* K1 = K2->leftChild;
286     SplayTreeNode* P = K2->parent;
287     K2->leftChild = K1->rightChild;
288     if(K2->leftChild){
289         K2->leftChild->parent = K2;
290     }
291     K1->rightChild = K2;
292     K1->rightChild->parent = K1;
293     K1->parent = P;
294     if (P != NULL) {
295         if (P->leftChild == K2) {
296             P->leftChild = K1;
297         } else {
298             P->rightChild = K1;
299         }
300     }
301     return K1;
302 }
303 // RR Rotation of Splay Tree
304 SplayTreeNode* SplaySingleRotateWithRight(SplayTreeNode* K2) {
305     // It is similar to AVL Tree
306     // But we must update the parent of node
307     SplayTreeNode* K1 = K2->rightChild;
308     SplayTreeNode* P = K2->parent;
309     K2->rightChild = K1->leftChild;
310     if(K2->rightChild){
311         K2->rightChild->parent = K2;    
312     }
313     K1->leftChild = K2;
314     if(K1->leftChild){
315         K1->leftChild->parent = K1;
316     }
317     
318     K1->parent = P;
319     if (P != NULL) {
320         if (P->leftChild == K2) {
321             P->leftChild = K1;
322         } else {
323             P->rightChild = K1;
324         }
325     }
326     return K1;
327 }
328 // LR Rotation
329 SplayTreeNode* SplayDoubleRotateWithLeft(SplayTreeNode* K3) {
330     K3->leftChild = SplaySingleRotateWithRight(K3->leftChild);
331     return SplaySingleRotateWithLeft(K3);
332 }
333 // RL Rotation
334 SplayTreeNode* SplayDoubleRotateWithRight(SplayTreeNode* K3) {
335     K3->rightChild = SplaySingleRotateWithLeft(K3->rightChild);
336     return SplaySingleRotateWithRight(K3);
337 }
338 // L-Zig-Zig
339 SplayTreeNode* ZigZigWithLeft(SplayTreeNode* K3) {
340     SplayTreeNode* parent = K3->parent;
341     SplayTreeNode* K2 = K3->leftChild;
342     SplayTreeNode* K1 = K2->leftChild;
343 
344     K3->leftChild = K2->rightChild;
345     if (K2->rightChild != NULL) {
346         K3->leftChild->parent = K3;
347     }
348     K2->rightChild = K3;
349     K2->rightChild->parent = K2;
350     K2->leftChild = K1->rightChild;
351     if (K1->rightChild != NULL) {
352         K2->leftChild->parent = K2;
353     }
354     K1->rightChild = K2;
355     K1->rightChild->parent = K1;
356     K1->parent = parent;
357     if (parent != NULL) {
358         if (parent->leftChild == K3) {
359             parent->leftChild = K1;
360         } else {
361             parent->rightChild = K1;
362         }
363     }
364     return K1;
365 }
366 // R-Zig-Zig
367 SplayTreeNode* ZigZigWithRight(SplayTreeNode* K3) {
368     SplayTreeNode* parent = K3->parent;
369     SplayTreeNode* K2 = K3->leftChild;
370     SplayTreeNode* K1 = K2->leftChild;
371 
372     K3->rightChild = K2->leftChild;
373     if (K2->leftChild != NULL) {
374         K3->rightChild->parent = K3;
375     }
376     K2->leftChild = K3;
377     K2->leftChild->parent = K2;
378     K2->rightChild = K1->leftChild;
379     if (K1->leftChild != NULL) {
380         K2->rightChild->parent = K2;
381     }
382     K1->leftChild = K2;
383     K1->leftChild->parent = K1;
384     K1->parent = parent;
385     if (parent != NULL) {
386         if (parent->leftChild == K3) {
387             parent->leftChild = K1;
388         } else {
389             parent->rightChild = K1;
390         }
391     }
392     return K1;
393 }
394 // Insert operation of Splay Tree without Splay
395 // It is similar to insert operation of Binery Search Tree
396 SplayTreeNode* PreInsert(int value, SplayTreeNode* T) {
397     if (T == NULL) {
398         T = new SplayTreeNode(value);
399     } else {
400         if (value < T->data) {
401             T->leftChild = PreInsert(value, T->leftChild);
402             // Update the parent of node
403             T->leftChild->parent = T;
404         } else if (value > T->data) {
405             T->rightChild = PreInsert(value, T->rightChild);
406             // Update the parent of node
407             T->rightChild->parent = T;
408         }
409     }
410     return T;
411 }
412 // Find the maximum element
413 SplayTreeNode* SplayTreeFindMax(SplayTreeNode* T) {
414     if (T == NULL) {
415         return NULL;
416     } else if (T->rightChild == NULL) {
417         return T;
418     } else {
419         return SplayTreeFindMax(T->rightChild);
420     }
421 }
422 // Find the minimum element
423 SplayTreeNode* SplayTreeFindMin(SplayTreeNode* T) {
424     if (T == NULL) {
425         return NULL;
426     } else if (T->leftChild == NULL) {
427         return T;
428     } else {
429         return SplayTreeFindMin(T->leftChild);
430     }
431 }
432 // Find the element and return the node
433 SplayTreeNode* Find(int value, SplayTreeNode* T) {
434     if (T == NULL) {
435         return NULL;
436     } else if (T->data == value) {
437         return T;
438     } else if (T->data > value) {
439         return Find(value, T->leftChild);
440     } else {
441         return Find(value, T->rightChild);
442     }
443 }
444 // Splay operation of Splay Tree
445 SplayTreeNode* Splay(int value, SplayTreeNode* T) {
446     SplayTreeNode* K = Find(value, T);
447     // Parent node
448     SplayTreeNode* P = NULL;
449     // Grandparent node
450     SplayTreeNode* GP = NULL;
451     // If node doesn‘t exist
452     if (K == NULL) {
453         return T;
454     }
455     // Do rotation until K arrives at root or is the child of root
456     while (T->leftChild != K && T->rightChild != K) {
457         P = K->parent;
458         // Break the loop if just need single rotation
459         if(P==NULL||P->parent==NULL){
460             break;
461         }
462         GP = P->parent;
463         if (GP->leftChild == P && P->leftChild == K) {
464             // L-Zig-Zig
465             ZigZigWithLeft(GP);
466         } else if (GP->leftChild == P && P->rightChild == K) {
467             // LR Rotation
468             SplayDoubleRotateWithLeft(GP);
469         } else if (GP->rightChild == P && P->leftChild == K) {
470             // RL Rotation
471             SplayDoubleRotateWithRight(GP);
472         } else if (GP->rightChild == P && P->rightChild == K) {
473             // R-Zig-Zig
474             ZigZigWithRight(GP);
475         }
476         // Return the new root if GP == T
477         if(GP == T){
478             return K;
479         }
480     }
481     if (T->leftChild == K) {
482         // LL Rotation
483         T = SplaySingleRotateWithLeft(T);
484     } else if (T->rightChild == K) {
485         // RR Rotation
486         T = SplaySingleRotateWithRight(T);
487     }
488     return T;
489 }
490 // Insert operation of Splay Tree
491 SplayTreeNode* SplayTreeInsert(int value, SplayTreeNode* T) {
492     // First insert the element just like Binery Search Tree
493     T = PreInsert(value, T);
494     // Then do the Splay
495     T = Splay(value, T);
496 }
497 // Splay operation of Splay Tree
498 SplayTreeNode* Splay(SplayTreeNode* node, SplayTreeNode* T) {
499       SplayTreeNode* K = node;
500     // Parent node
501     SplayTreeNode* P = NULL;
502     // Grandparent node
503     SplayTreeNode* GP = NULL;
504     // If node doesn‘t exist
505     if(K == NULL){
506         return T;
507     }
508     // Do rotation until K arrives at root or is the child of root
509     while (T->leftChild != K && T->rightChild != K) {
510         P = K->parent;
511         // Break the loop if just need single rotation
512         if(P==NULL||P->parent==NULL){
513             break;
514         }
515         GP = P->parent;
516         if (GP->leftChild == P && P->leftChild == K) {
517             // L-Zig-Zig
518             ZigZigWithLeft(GP);
519         } else if (GP->leftChild == P && P->rightChild == K) {
520             // LR Rotation
521             SplayDoubleRotateWithLeft(GP);
522         } else if (GP->rightChild == P && P->leftChild == K) {
523             // RL Rotation
524             SplayDoubleRotateWithRight(GP);
525         } else if (GP->rightChild == P && P->rightChild == K) {
526             // R-Zig-Zig
527             ZigZigWithRight(GP);
528         }
529         // Return the new root if GP == T
530         if(GP == T){
531             return K;
532         }
533     }
534     if (T->leftChild == K) {
535         // LL Rotation
536         T = SplaySingleRotateWithLeft(T);
537     } else if (T->rightChild == K) {
538         // RR Rotation
539         T = SplaySingleRotateWithRight(T);
540     }
541     return T;
542 }
543 // Delete operation of Splay Tree
544 SplayTreeNode* SplayTreeDelete(int value, SplayTreeNode* T) {
545     // If T is NULL
546     if (!T) {
547         return NULL;
548     }
549     // First do the Splay operation
550     T = Splay(value, T);
551     // Leftchild of root
552     SplayTreeNode* L = T->leftChild;
553     // Rightchild of root
554     SplayTreeNode* R = T->rightChild;
555     // If the tree doesn‘t have rightchild
556     if(R==NULL){
557         R = L;
558         if (L) {
559             R->parent = NULL;
560         }
561     }
562     else{
563         R->parent = NULL;
564         // Find the minimum element of R
565         R = Splay(SplayTreeFindMin(R), R);
566         R-> leftChild = L;
567         if(L){
568             L->parent = R;
569         }
570     }
571     // Delete the element
572     delete T;
573     return R;
574 }