AVLtree（C++实现）有统一的旋转操作

在学习完AVLtree之后，我发现，左旋，右旋均可以采用统一的旋转方式来实现，所以把代码贴在下面

代码是完整的AVLTree实现

C++标准为C++11

在ubuntu 18.04下通过编译和调试

  1 /*
  2  * BinarySearchTree.h
  3  *  1. 添加元素时需自己做判断元素是否合法
  4  *  2. 除层序遍历外，本源代码均采用递归遍历，若要减少栈的消耗，应该实现递归遍历
  5  *  3. 本代码实现的AVL树有统一旋转操作，不用分情况讨论LL,LR,RR,RL来进行树的平衡
  6  *     统一旋转操作有特殊优化版本和统一接口版本，本代码保留了统一接口的源码，但是采用的是特殊优化版本
  7  *  Created on: 2020年1月29日
  8  *      Author: LuYonglei
  9  */
 10 
 11 #ifndef SRC_BINARYSEARCHTREE_H_
 12 #define SRC_BINARYSEARCHTREE_H_
 13 #include 
 14 
 15 template
 16 class BinarySearchTree {
 17 public:
 18 
 19     BinarySearchTree(int (*cmp)(Element e1, Element e2)); //比较函数指针
 20 
 21     virtual ~BinarySearchTree();
 22 
 23     int size(); //元素的数量
 24 
 25     bool isEmpty(); //是否为空
 26 
 27     void clear() {
 28         //清空所有元素
 29         NODE *node = root_;
 30         root_ = nullptr;
 31         using namespace std;
 32         queue q;
 33         q.push(node);
 34         while (!q.empty()) {
 35             NODE *tmp = q.front();
 36             if (tmp->left != nullptr)
 37                 q.push(tmp->left);
 38             if (tmp->right != nullptr)
 39                 q.push(tmp->right);
 40             delete tmp;
 41             q.pop();
 42         }
 43     }
 44 
 45     void add(Element e) {
 46         //添加元素
 47         add(e, cmp_);
 48     }
 49 
 50     void remove(Element e) {
 51         //删除元素
 52         remove(Node(e, cmp_));
 53     }
 54 
 55     bool contains(Element e) {
 56         //是否包含某元素
 57         return Node(e, cmp_) != nullptr;
 58     }
 59 
 60     void preorderTraversal(bool (*visitor)(Element &e)) {
 61         //前序遍历
 62         if (visitor == nullptr)
 63             return;
 64         bool stop = false; //停止标志，若stop为true，则停止遍历
 65         preorderTraversal(root_, stop, visitor);
 66     }
 67 
 68     void inorderTraversal(bool (*visitor)(Element &e)) {
 69         //中序遍历
 70         if (visitor == nullptr)
 71             return;
 72         bool stop = false; //停止标志，若stop为true，则停止遍历
 73         inorderTraversal(root_, stop, visitor);
 74     }
 75 
 76     void postorderTraversal(bool (*visitor)(Element &e)) {
 77         //后序遍历
 78         if (visitor == nullptr)
 79             return;
 80         bool stop = false; //停止标志，若stop为true，则停止遍历
 81         postorderTraversal(root_, stop, visitor);
 82     }
 83 
 84     void levelOrderTraversal(bool (*visitor)(Element &e)) {
 85         //层序遍历，迭代实现
 86         if (visitor == nullptr)
 87             return;
 88         levelOrderTraversal(root_, visitor);
 89     }
 90 
 91     int height() {
 92         //树的高度
 93         return height(root_);
 94     }
 95 
 96     bool isComplete() {
 97         //判断是否是完全二叉树
 98         return isComplete(root_);
 99     }
100 
101 private:
102 
103     int size_;
104 
105     typedef struct _Node {
106         Element e;
107         _Node *parent;
108         _Node *left;
109         _Node *right;
110         int height; //节点的高度
111         _Node(Element e_, _Node *parent_) :
112                 e(e_), parent(parent_), left(nullptr), right(nullptr), height(1) {
113             //节点构造函数
114         }
115 
116         inline bool isLeaf() {
117             return (left == nullptr && right == nullptr);
118         }
119 
120         inline bool hasTwoChildren() {
121             return (left != nullptr && right != nullptr);
122         }
123 
124         inline int balanceFactor() {
125             //获得节点的平衡因子
126             int leftHeight = left == nullptr ? 0 : left->height; //获得左子树的高度
127             int rightHeight = right == nullptr ? 0 : right->height; //获得右子树的高度
128             return leftHeight - rightHeight;
129         }
130 
131         inline bool isBalanced() {
132             //判断node是否平衡
133             int balanceFactor_ = balanceFactor();
134             return balanceFactor_ >= -1 && balanceFactor_ <= 1; //平衡因子为-1,0,1则返回true
135         }
136 
137         inline void updateHeight() {
138             //更新节点的高度
139             int leftHeight = left == nullptr ? 0 : left->height; //获得左子树的高度
140             int rightHeight = right == nullptr ? 0 : right->height; //获得右子树的高度
141             height = 1 + (leftHeight > rightHeight ? leftHeight : rightHeight); //把节点高度更新为左右子树最大的高度+1
142         }
143 
144         inline bool isLeftChild() {
145             //判断节点是否是父亲节点的左子结点
146             return parent != nullptr && parent->left == this;
147         }
148 
149         inline bool isRightChild() {
150             //判断节点是否是父亲节点的右子结点
151             return parent != nullptr && parent->right == this;
152         }
153 
154         inline _Node* tallerChild() {
155             //获得高度更高的子树
156             int leftHeight = left == nullptr ? 0 : left->height; //获得左子树的高度
157             int rightHeight = right == nullptr ? 0 : right->height; //获得右子树的高度
158             if (leftHeight > rightHeight)
159                 return left;
160             if (leftHeight < rightHeight)
161                 return right;
162             return isLeftChild() ? left : right;
163         }
164 
165     } NODE;
166 
167     NODE *root_;
168 
169     int (*cmp_)(Element e1, Element e2); //为实现树的排序的个性化配置，私有成员保存一个比较函数指针
170 
171     NODE* Node(Element e, int (*cmp_)(Element e1, Element e2)) {
172         //返回e元素所在的节点
173         NODE *node = root_;
174         while (node != nullptr) {
175             int cmp = cmp_(e, node->e);
176             if (cmp == 0) //找到了元素
177                 return node;
178             if (cmp > 0) { //待寻找元素大于节点存储的元素
179                 node = node->right;
180             } else { //待寻找元素小于节点存储的元素
181                 node = node->left;
182             }
183         }
184         return nullptr;
185     }
186 
187     NODE* predecessor(NODE *node) {
188         //返回node的前驱节点
189         if (node == nullptr)
190             return nullptr;
191         //前驱节点在左子树
192         NODE *tmp = node->left;
193         if (tmp != nullptr) {
194             while (tmp->right != nullptr)
195                 tmp = tmp->right;
196             return tmp;
197         }
198         //从父节点，祖父节点中寻找前驱节点
199         while (node->parent != nullptr && node == node->parent->left) {
200             node = node->parent;
201         }
202         return node->parent;
203     }
204 
205     NODE* successor(NODE *node) {
206         //返回node的后继节点
207         if (node == nullptr)
208             return nullptr;
209         //后继节点在右子树
210         NODE *tmp = node->right;
211         if (tmp != nullptr) {
212             while (tmp->left != nullptr)
213                 tmp = tmp->left;
214             return tmp;
215         }
216         //从父节点，祖父节点中寻找后继节点
217         while (node->parent != nullptr && node == node->parent->right) {
218             node = node->parent;
219         }
220         return node->parent;
221     }
222 
223 #if 0
224     //统一接口版本(未优化)
225     void rotate(NODE *r, NODE *a, NODE *b, NODE *c, NODE *d, NODE *e, NODE *f,
226             NODE *g) {
227         //统一的旋转操作
228         /* r是变换前高度最低的不平衡节点
229          * 传入的参数a,b,c,d,e,f,g是经过变换后节点应该在的位置
230          *        d
231          *      /   \
232          *     b     f
233          *    / \   / \
234          *   a   c e   g
235          *   a,c,e,g均有可能为空，所以要对它们做判空处理
236          *   b,d,f绝不为空
237          *   d的parent可能为null，则d就为根节点，所以就要改变树中root_的指向
238          */
239         //对d节点做处理
240         d->parent = r->parent;
241         if (r->isLeftChild())
242             r->parent->left = d;
243         else if (r->isRightChild())
244             r->parent->right = d;
245         else
246             root_ = d;
247         //a-b-c
248         b->left = a;
249         b->right = c;
250         if (a != nullptr)
251             a->parent = b;
252         if (c != nullptr)
253             c->parent = b;
254         b->updateHeight();
255         //e-f-g
256         f->left = e;
257         f->right = g;
258         if (e != nullptr)
259             e->parent = f;
260         if (g != nullptr)
261             g->parent = f;
262         f->updateHeight();
263         //b-d-f
264         d->left = b;
265         d->right = f;
266         b->parent = d;
267         f->parent = d;
268         d->updateHeight();
269     }
270 
271     void rebalance(NODE *gNode) {
272         //恢复平衡,grand为高度最低的不平衡节点
273         NODE *pNode = gNode->tallerChild();
274         NODE *nNode = pNode->tallerChild();
275         if (pNode->isLeftChild()) {
276             if (nNode->isLeftChild()) {
277                 //LL
278                 /*
279                  *          gNode(f)
280                  *         /      \        变换后
281                  *        pNode(d) g       ====>        pNode(d)
282                  *       /      \                      /        \
283                  *      nNode(b) e                   nNode(b)   gNode(f)
284                  *     /      \                      /     \    /     \
285                  *    a        c                    a       c  e       g
286                  */
287                 rotate(gNode, nNode->left, nNode, nNode->right, pNode,
288                         pNode->right, gNode, gNode->right);
289             } else {
290                 //LR
291                 /*
292                  *       gNode(f)
293                  *      /       \       变换后
294                  *     pNode(b)  g       ====>        nNode(d)
295                  *    /    \                         /        \
296                  *   a   nNode(d)                  pNode(b)  gNode(f)
297                  *       /    \                    /     \   /     \
298                  *      c      e                  a       c e       g
299                  */
300                 rotate(gNode, pNode->left, pNode, nNode->left, nNode,
301                         nNode->right, gNode, gNode->right);
302             }
303         } else {
304             if (nNode->isLeftChild()) {
305                 //RL
306                 /*
307                  *    gNode(b)
308                  *   /     \             变换后
309                  *  a       pNode(f)     ====>          nNode(d)
310                  *         /      \                    /       \
311                  *        nNode(d) g                 gNode(b)  pNode(f)
312                  *       /    \                      /    \    /     \
313                  *      c      e                    a      c  e       g
314                  */
315                 rotate(gNode, gNode->left, gNode, nNode->left, nNode,
316                         nNode->right, pNode, pNode->right);
317             } else {
318                 //RR
319                 /*
320                  *   gNode(b)
321                  *    /    \            变换后
322                  *   a     pNode(d)     ====>       pNode(d)
323                  *         /     \                  /       \
324                  *        c      nNode(f)         gNode(b)  nNode(f)
325                  *              /     \           /     \    /    \
326                  *             e       g         a       c  e      g
327                  */
328                 rotate(gNode, gNode->left, gNode, pNode->left, pNode,
329                         nNode->left, nNode, nNode->right);
330             }
331         }
332     }
333 
334 #endif
335 
336     void rotate(NODE *r, NODE *b, NODE *c, NODE *d, NODE *e, NODE *f) {
337         //统一的旋转操作
338         /* r是变换前高度最低的不平衡节点
339          * 传入的参数b,c,d,e,f是经过变换后节点应该在的位置
340          *        d
341          *      /   \
342          *     b     f
343          *    / \   / \
344          *   a   c e   g
345          *   c,e均有可能为空，所以要对它们做判空处理
346          *   b,d,f绝不为空
347          *   d的parent可能为null，则d就为根节点，所以就要改变树中root_的指向
348          */
349         //对d节点做处理
350         d->parent = r->parent;
351         if (r->isLeftChild())
352             r->parent->left = d;
353         else if (r->isRightChild())
354             r->parent->right = d;
355         else
356             root_ = d;
357         //b-c
358         b->right = c;
359         if (c != nullptr)
360             c->parent = b;
361         b->updateHeight();
362         //e-f
363         f->left = e;
364         if (e != nullptr)
365             e->parent = f;
366         f->updateHeight();
367         //b-d-f
368         d->left = b;
369         d->right = f;
370         b->parent = d;
371         f->parent = d;
372         d->updateHeight();
373     }
374 
375     void rebalance(NODE *gNode) {
376         //恢复平衡,grand为高度最低的不平衡节点
377         NODE *pNode = gNode->tallerChild();
378         NODE *nNode = pNode->tallerChild();
379         if (pNode->isLeftChild()) {
380             if (nNode->isLeftChild()) {
381                 //LL
382                 /*
383                  *          gNode(f)
384                  *         /      \        变换后
385                  *        pNode(d) g       ====>        pNode(d)
386                  *       /      \                      /        \
387                  *      nNode(b) e                   nNode(b)   gNode(f)
388                  *     /      \                      /     \    /     \
389                  *    a        c                    a       c  e       g
390                  */
391                 rotate(gNode, nNode, nNode->right, pNode, pNode->right, gNode);
392             } else {
393                 //LR
394                 /*
395                  *       gNode(f)
396                  *      /       \       变换后
397                  *     pNode(b)  g       ====>        nNode(d)
398                  *    /    \                         /        \
399                  *   a   nNode(d)                  pNode(b)  gNode(f)
400                  *       /    \                    /     \   /     \
401                  *      c      e                  a       c e       g
402                  */
403                 rotate(gNode, pNode, nNode->left, nNode, nNode->right, gNode);
404             }
405         } else {
406             if (nNode->isLeftChild()) {
407                 //RL
408                 /*
409                  *    gNode(b)
410                  *   /     \             变换后
411                  *  a       pNode(f)     ====>          nNode(d)
412                  *         /      \                    /       \
413                  *        nNode(d) g                 gNode(b)  pNode(f)
414                  *       /    \                      /    \    /     \
415                  *      c      e                    a      c  e       g
416                  */
417                 rotate(gNode, gNode, nNode->left, nNode, nNode->right, pNode);
418             } else {
419                 //RR
420                 /*
421                  *   gNode(b)
422                  *    /    \            变换后
423                  *   a     pNode(d)     ====>       pNode(d)
424                  *         /     \                  /       \
425                  *        c      nNode(f)         gNode(b)  nNode(f)
426                  *              /     \           /     \    /    \
427                  *             e       g         a       c  e      g
428                  */
429                 rotate(gNode, gNode, pNode->left, pNode, nNode->left, nNode);
430             }
431         }
432     }
433 
434     void afterAdd(NODE *node) {
435         //添加node之后的调整
436         if (node == nullptr)
437             return;
438         node = node->parent;
439         while (node != nullptr) {
440             if (node->isBalanced()) {
441                 //如果节点平衡，则对其更新高度
442                 node->updateHeight();
443             } else {
444                 //此时对第一个不平衡节点操作，使其平衡
445                 rebalance(node);
446                 //整棵树恢复平衡后,跳出循环
447                 break;
448             }
449             node = node->parent;
450         }
451     }
452 
453     void add(Element e, int (*cmp_)(Element e1, Element e2)) {
454         //当树为空时，添加的节点作为树的根节点
455         if (root_ == nullptr) {
456             root_ = new NODE(e, nullptr);
457             size_++;
458             //插入一个根节点之后进行调整
459             afterAdd(root_);
460             return;
461         }
462         //当添加的节点不是第一个节点
463         NODE *parent = root_;
464         NODE *node = root_;
465         int cmp = 0; //比较结果
466         while (node != nullptr) {
467             parent = node; //保存父节点
468             cmp = cmp_(e, node->e); //由函数指针来比较
469             if (cmp > 0) {
470                 node = node->right; //添加的元素大于节点中的元素
471             } else if (cmp < 0) {
472                 node = node->left; //添加的元素小于节点中的元素
473             } else {
474                 node->e = e; //相等时就覆盖
475                 return; //添加的元素等于节点中的元素,直接返回
476             }
477         }
478         //判断要插入父节点的哪个位置
479         NODE *newNode = new NODE(e, parent); //为新元素创建节点
480         if (cmp > 0) {
481             parent->right = newNode; //添加的元素大于节点中的元素
482         } else {
483             parent->left = newNode; //添加的元素小于节点中的元素
484         }
485         size_++;
486         //添加一个新节点之后进行调整
487         afterAdd(newNode);
488     }
489 
490     void afterRemove(NODE *node) {
491         //删除node之后的调整
492         if (node == nullptr)
493             return;
494         node = node->parent;
495         while (node != nullptr) {
496             if (node->isBalanced()) {
497                 //如果节点平衡，则对其更新高度
498                 node->updateHeight();
499             } else {
500                 //此时对不平衡节点操作，使其平衡
501                 rebalance(node);
502             }
503             node = node->parent;
504         }
505     }
506 
507     void remove(NODE *node_) {
508         //删除某一节点
509         if (node_ == nullptr)
510             return;
511         size_--;
512         //优先删除度为2的节点
513         if (node_->hasTwoChildren()) {
514             NODE *pre = successor(node_); //找到node_的后继节点
515             node_->e = pre->e; //用后继节点的值覆盖度为2的节点的值
516             //删除后继节点(后继节点的度只能为1或0)
517             node_ = pre;
518         }
519         //此时node_的度必然为0或1
520         NODE *replacement = node_->left != nullptr ? node_->left : node_->right;
521         if (replacement != nullptr) {            //node_的度为1
522             replacement->parent = node_->parent;
523             if (node_->parent == nullptr)            //度为1的根节点
524                 root_ = replacement;
525             else if (node_->parent->left == node_)
526                 node_->parent->left = replacement;
527             else
528                 node_->parent->right = replacement;
529             //所有删除操作准备完成，准备释放节点内存前进行平衡操作
530             afterRemove(node_);
531             delete node_;
532         } else if (node_->parent == nullptr) {            //node_是叶子节点，也是根节点
533             root_ = nullptr;
534             //所有删除操作准备完成，准备释放节点内存前进行平衡操作
535             afterRemove(node_);
536             delete node_;
537         } else {            //node_是叶子节点，但不是根节点
538             if (node_->parent->left == node_)
539                 node_->parent->left = nullptr;
540             else
541                 node_->parent->right = nullptr;
542             //所有删除操作准备完成，准备释放节点内存前进行平衡操作
543             afterRemove(node_);
544             delete node_;
545         }
546     }
547 
548     void preorderTraversal(NODE *node, bool &stop,
549             bool (*visitor)(Element &e)) {
550         //递归实现前序遍历
551         if (node == nullptr || stop == true)
552             return;
553         stop = visitor(node->e);
554         preorderTraversal(node->left, stop, visitor);
555         preorderTraversal(node->right, stop, visitor);
556     }
557 
558     void inorderTraversal(NODE *node, bool &stop, bool (*visitor)(Element &e)) {
559         //递归实现中序遍历
560         if (node == nullptr || stop == true)
561             return;
562         inorderTraversal(node->left, stop, visitor);
563         if (stop == true)
564             return;
565         stop = visitor(node->e);
566         inorderTraversal(node->right, stop, visitor);
567     }
568 
569     void postorderTraversal(NODE *node, bool &stop,
570             bool (*visitor)(Element &e)) {
571         //递归实现后序遍历
572         if (node == nullptr || stop == true)
573             return;
574         postorderTraversal(node->left, stop, visitor);
575         postorderTraversal(node->right, stop, visitor);
576         if (stop == true)
577             return;
578         stop = visitor(node->e);
579     }
580 
581     void levelOrderTraversal(NODE *node, bool (*visitor)(Element &e)) {
582         if (node == nullptr)
583             return;
584         using namespace std;
585         queue q;
586         q.push(node);
587         while (!q.empty()) {
588             NODE *node = q.front();
589             if (visitor(node->e) == true)
590                 return;
591             if (node->left != nullptr)
592                 q.push(node->left);
593             if (node->right != nullptr)
594                 q.push(node->right);
595             q.pop();
596         }
597     }
598 
599     int height(NODE *node) {
600         //某一节点的高度
601         return node->height;
602     }
603 
604     bool isComplete(NODE *node) {
605         if (node == nullptr)
606             return false;
607         using namespace std;
608         queue q;
609         q.push(node);
610         bool leaf = false; //判断接下来的节点是否为叶子节点
611         while (!q.empty()) {
612             NODE *node = q.front();
613             if (leaf && !node->isLeaf()) //判断叶子节点
614                 return false;
615             if (node->left != nullptr) {
616                 q.push(node->left);
617             } else if (node->right != nullptr) { //node->left == nullptr && node->right != nullptr
618                 return false;
619             }
620             if (node->right != nullptr) {
621                 q.push(node->right);
622             } else { //node->right==nullptr
623                 leaf = true;
624             }
625             q.pop();
626         }
627         return true;
628     }
629 
630 };
631 
632 template
633 BinarySearchTree::BinarySearchTree(int (*cmp)(Element e1, Element e2)) :
634         size_(0), root_(nullptr), cmp_(cmp) {
635     //树的构造函数
636 }
637 
638 template
639 BinarySearchTree::~BinarySearchTree() {
640     // 析构函数
641     clear();
642 }
643 
644 template
645 inline int BinarySearchTree::size() {
646     //返回元素个数
647     return size_;
648 }
649 
650 template
651 inline bool BinarySearchTree::isEmpty() {
652     //判断是否为空树
653     return size_ == 0;
654 }
655 
656 #endif /* SRC_BINARYSEARCHTREE_H_ */

 

 

main方法

 1 /*
 2  * main.cpp
 3  *
 4  *  Created on: 2020年1月29日
 5  *      Author: LuYonglei
 6  */
 7 
 8 #include "BinarySearchTree.h"
 9 #include 
10 #include 
11 
12 using namespace std;
13 
14 template
15 int compare(Element e1, Element e2) {
16     //比较函数,相同返回0,e1e2返回1
17     return e1 == e2 ? 0 : (e1 < e2 ? -1 : 1);
18 }
19 
20 template
21 bool visitor(Elemnet &e) {
22     cout << e << " ";
23     cout << endl;
24     return false; //若返回true，则在遍历时会退出
25 }
26 
27 int main(int argc, char **argv) {
28     BinarySearchTree<double> a(compare);
29 //    a.add(85);
30 //    a.add(19);
31 //    a.add(69);
32 //    a.add(3);
33 //    a.add(7);
34 //    a.add(99);
35 //    a.add(95);
36 //    a.add(2);
37 //    a.add(1);
38 //    a.add(70);
39 //    a.add(44);
40 //    a.add(58);
41 //    a.add(11);
42 //    a.add(21);
43 //    a.add(14);
44 //    a.add(93);
45 //    a.add(57);
46 //    a.add(4);
47 //    a.add(56);
48     clock_t start = clock();
49     for (int i = 0; i < 1000000; i++) {
50         a.add(i);
51     }
52     for (int i = 0; i < 1000000; i++) {
53         a.remove(i);
54     }
55 //    a.inorderTraversal(visitor);
56     clock_t end = clock();
57     cout << end - start << endl;
58 //    cout <59 //    cout << a.isComplete() << endl;
60 //    a.remove(7);
61 //    a.clear();
62 //    a.levelOrderTraversal(visitor);
63 //    cout << endl;
64 //    cout<
65 }