编程练习——平衡树（AVLTree）

最新推荐文章于 2024-01-25 20:29:00 发布
最新推荐文章于 2024-01-25 20:29:00 发布
阅读量1k 收藏
点赞数
分类专栏： c/c++ 数据结构&算法 文章标签： 编程 null c search 测试 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cctt_1/article/details/2797126
版权

AVLTree本身就是二叉查找树。为了保证查找效率在O(nlogn),所以有时要对树高进行必要的调整。

AVLTree拥有自己的法则使得插入、删除、查找都在O(nlogn)时间内完成。

下面写了一个AVLTreeNode类，好像和TreeNode类一样。

 

下面写AVLTree类，这个类重要的地方在与插入和删除操作。查找操作和BinarySearchTree一致。但是至今还没有找到一个有效的方法来使用BinarySearchTree中的Search。除非将Search方法抽象为一个接口。

暂时先不管太多。

先看左旋和右旋操作。

  1. // return the subRoot
  2.     //        a                   b
  3.     //       /                  /   /
  4.     //      b        ->        c     a
  5.     //     /
  6.     //    c
  7.     AVLNode<T>* LLRotate(AVLNode<T>* a, AVLNode<T>* b)
  8.     {
  9.         a->setLeft(b->getRight());
  10.         b->setRight(a);
  11.         
  12.         a->setAHeight(0);
  13.         b->setAHeight(0);
  14.         //a->setAHeight(getAVLHeight(a));
  15.         //b->setAHeight(getAVLHeight(b));
  16.         return b;
  17.     }
  19.     // return the subRoot
  20.     //        a                      b
  21.     //          /                  /   /
  22.     //            b        ->     a     c
  23.     //              /
  24.     //                c
  25.     AVLNode<T>* RRRotate(AVLNode<T>* a, AVLNode<T>* b)
  26.     {
  27.         a->setRight(b->getLeft());
  28.         b->setLeft(a);
  29.         
  30.         a->setAHeight(0);
  31.         b->setAHeight(0);
  32.         //a->setAHeight(getAVLHeight(a));
  33.         //b->setAHeight(getAVLHeight(b));
  34.         return b;
  35.     }
  38.     // return the subRoot
  39.     //        a                      c
  40.     //          /                  /   /
  41.     //            b        ->     a     b
  42.     //           /                 /      
  43.     //          c                   d  
  44.     //         /
  45.     //        d
  46.     AVLNode<T>* RLRotate(AVLNode<T>* a, AVLNode<T>* b, AVLNode<T>* c)
  47.     {
  48.         
  49.         b->setLeft(c->getRight());
  50.         c->setRight(b);
  51.         a->setRight(c->getLeft());
  52.         c->setLeft(a);
  53.         
  54.         
  55.         //a->setAHeight(getAVLHeight(a));
  56.         //c->setAHeight(getAVLHeight(c));
  57.         //b->setAHeight(getAVLHeight(b));
  59.         if(c->getAbsoluteAHeight() == 1)
  60.         {
  61.             if(b->getAHeight() == 0)
  62.             {
  63.                 b->setAHeight(-1);
  64.             }
  65.             else
  66.             {
  67.                 b->setAHeight(0);
  68.             }
  69.             a->setAHeight(1);
  70.             c->setAHeight(0);
  71.         
  72.         }
  73.         else
  74.         {
  75.             if(b->getAHeight() == 0)
  76.             {
  77.                 b->setAHeight(-1);
  78.             }
  79.             else
  80.             {
  81.                 b->setAHeight(0);
  82.             }
  83.             a->setAHeight(0);
  84.             c->setAHeight(0);
  85.             
  86.         }
  87.         
  88.         
  89.         return c;
  90.     }
  92.     // return the subRoot
  93.     //        a                      c
  94.     //       /                     /   /
  95.     //      b              ->     b     a
  96.     //       /                         /       
  97.     //        c                       d   
  98.     //         /
  99.     //          d
  100.     AVLNode<T>* LRRotate(AVLNode<T>* a, AVLNode<T>* b, AVLNode<T>* c)
  101.     {
  102.         b->setRight(c->getLeft());
  103.         c->setLeft(b);
  104.         a->setLeft(c->getRight());
  105.         c->setRight(a);
  106.         
  107.         
  108.         //a->setAHeight(getAVLHeight(a));
  109.         //c->setAHeight(getAVLHeight(c));
  110.         //b->setAHeight(getAVLHeight(b));
  112.         if(c->getAbsoluteAHeight() == 1)
  113.         {
  114.             if(b->getAHeight() == 0)
  115.             {
  116.                 b->setAHeight(1);
  117.             }
  118.             else
  119.             {
  120.                 b->setAHeight(0);
  121.             }
  123.             a->setAHeight(-1);
  124.             c->setAHeight(0);
  125.             
  126.         }
  127.         else
  128.         {
  130.             if(b->getAHeight() == 0)
  131.             {
  132.                 b->setAHeight(1);
  133.             }
  134.             else
  135.             {
  136.                 b->setAHeight(0);
  137.             }
  138.             a->setAHeight(0);
  139.             c->setAHeight(0);
  140.         
  141.         }
  142.         
  143.         
  144.         
  146.         return c;
  147.     }

这里旋转后调整平衡因子是关键部分。这是我自己总结的方法，经少量测试暂时没有出现问题。这个调整方法好像与大多数书本和网络程序的方法不一致。不清楚到底哪个是正确的。但是如果不使用这种直接赋值的方法，可以使用递归查找树高的方法保障万无一失的解决这个问题。这里使用的右树高减左树高得平衡因子的方法。

下面给出这样的两个函数，其中getAVLHeight是核心方法。

 

  1.     int getHeight(AVLNode<T>* node)
  2.     {
  3.         if(node == NULL)
  4.         {
  5.             return 0;
  6.         }
  7.         else
  8.         {
  9.             int leftHeight = getHeight(node->getLeft());
  10.             int rightHeight = getHeight(node->getRight());
  11.             if(leftHeight > rightHeight)
  12.             {
  13.                 return leftHeight+1;
  14.             }
  15.             else
  16.             {
  17.                 return rightHeight+1;
  18.             }
  19.         }
  20.     }
  22.     int getAVLHeight(AVLNode<T>* node)
  23.     {
  24.         if(node == NULL)
  25.         {
  26.             return 0;
  27.         }
  28.         else
  29.         {
  30.             int leftHeight = getHeight(node->getLeft());
  31.             int rightHeight = getHeight(node->getRight());
  32.             return rightHeight - leftHeight;
  33.         }
  34.     }

删除、插入操作有点复杂。

插入操作：

1.先找到可能要调整的那个节点A，这里的可能要调整的节点即为插入路径中平衡因子为+1或者为-1的点。（这里一定要记得不要自作聪明的认为如果向左插入，+1节点就不会是可能节点）

2.插入应该插入的节点，调整从A至目标节点的平衡因子。并且记录是否增长了子树树高（是否插入节点没有兄弟节点）。

3.插入后查看是否增长子树树高，如果增长树高，再查看A是否已经不平衡。如果不平衡，调整，否则，插入完成。

（这里要注意A节点为树根的情况，或者无A节点的情况）

因为下面的程序首先将树根设定为可能要调整的节点A，所以没有出现无A节点的情况。

以上三点，我看过很多教科书，发现讲解有些含糊，或者本身就是略写。这里并没有采用递归操作。

 

  1.     void insertNode(AVLNode<T>* node)
  2.     {
  3.         AVLNode<T>* subRoot = this->head;
  4.         if(subRoot == NULL)
  5.         {
  6.             subRoot = node;
  7.             return;
  8.         }
  9.         AVLNode<T>* ppoRoot = NULL;
  10.         AVLNode<T>* poRoot = NULL;
  11.         AVLNode<T>* pRoot = NULL;
  12.         
  13.     
  15.         poRoot = subRoot;
  16.         
  17.         while(subRoot != NULL)
  18.         {
  19.             pRoot = subRoot;
  20.             if(subRoot->getData() > node->getData())
  21.             {
  22.                 
  23.                 if(isPossibleNode(subRoot->getLeft(),node))
  24.                 {
  25.                     poRoot = subRoot->getLeft();
  26.                     ppoRoot = subRoot;
  27.                 }
  28.                 subRoot = subRoot->getLeft();
  30.             }
  31.             else if(subRoot->getData() < node->getData())
  32.             {
  33.                 
  34.                 if(isPossibleNode(subRoot->getRight(),node))
  35.                 {
  36.                     poRoot = subRoot->getRight();
  37.                     ppoRoot = subRoot;
  38.                 }
  39.                 subRoot = subRoot->getRight();
  40.             }
  41.             else
  42.             {
  43.                 throw "the same key";
  44.             }
  45.         }
  47.         bool isChangeHeight = false;
  48.         if(pRoot->getData() > node->getData())
  49.         {
  50.         
  51.             pRoot->setLeft(node);
  52.             if(pRoot->getRight() == NULL)
  53.             {
  54.                 isChangeHeight = true;
  55.             }
  56.             else
  57.             {
  58.                 pRoot->setAHeight(pRoot->getAHeight()-1);
  59.             }
  60.         }
  61.         else if(pRoot->getData() < node->getData())
  62.         {
  63.             
  64.             pRoot->setRight(node);
  65.             if(pRoot->getLeft() == NULL)
  66.             {
  67.                 isChangeHeight = true;
  68.             }
  69.             else
  70.             {
  71.                 pRoot->setAHeight(pRoot->getAHeight()+1);
  72.             }
  73.         }
  76.         if(poRoot != NULL && isChangeHeight)
  77.         {
  78.             // s->a update Height
  79.             subRoot = poRoot;
  80.             while(subRoot != node)
  81.             {
  82.                 if(subRoot->getData() > node->getData())
  83.                 {
  84.                     subRoot->setAHeight(subRoot->getAHeight()-1);
  85.                     
  86.                     subRoot = subRoot->getLeft();
  88.                 }
  89.                 else if(subRoot->getData() < node->getData())
  90.                 {
  91.                     subRoot->setAHeight(subRoot->getAHeight()+1);
  92.                     
  93.                     subRoot = subRoot->getRight();
  95.                 }
  97.             }
  99.             subRoot = poRoot;
  100.             AVLNode<T>* a = poRoot;
  101.             AVLNode<T>* b = NULL;
  102.             AVLNode<T>* c = NULL;
  103.             AVLNode<T>* tempRoot = NULL;
  104.             if(a->getAbsoluteAHeight() > 1)
  105.             {
  106.                 if(subRoot->getData() > node->getData())
  107.                 {
  108.                     b = subRoot->getLeft();
  109.                     if(a->getAHeight()* b->getAHeight() > 0)
  110.                     {
  111.                         //LLRotate
  112.                         tempRoot = LLRotate(a,b);
  113.                         
  114.                     }
  115.                     else
  116.                     {
  117.                         //LRRotate
  118.                         c = b->getRight();
  119.                         tempRoot =LRRotate(a,b,c);
  120.                     }
  121.                     
  122.                 }
  123.                 else if(subRoot->getData() < node->getData())
  124.                 {
  125.                     b = subRoot->getRight();
  126.                     if(a->getAHeight()* b->getAHeight() > 0)
  127.                     {
  128.                         //RRRotate
  129.                         tempRoot = RRRotate(a,b);
  130.                     }
  131.                     else
  132.                     {
  133.                         //RLRotate
  134.                         c = b->getLeft();
  135.                         tempRoot =RLRotate(a,b,c);
  136.                     }
  137.                 }
  138.                 if(ppoRoot!=NULL)
  139.                 {
  140.                     if(ppoRoot->getData() > tempRoot->getData())
  141.                     {
  142.                         ppoRoot->setLeft(tempRoot);
  143.                     }
  144.                     else
  145.                     {
  146.                         ppoRoot->setRight(tempRoot);
  147.                     }
  148.                 }
  149.                 else
  150.                 {
  151.                     this->head = tempRoot;
  152.                 }
  153.             }
  154.             
  156.         }
  158.     }

再看删除操作。

采用的是http://www.cs.uga.edu/~eileen/2720/Notes/AVLTrees-II.ppt这个ppt介绍的删除操作。

因为删除操作要反遍历到树根，所以这里无奈采用是递归操作。

bool deleteNode(AVLNode<T>* subRoot, AVLNode<T>* prev, T& node);

这个操作返回值：如果子树树高变化，那么返回true,否则返回false。

1.如果子树为Null，函数返回false

2.比较subRoot里的data值和node中的data值。

    A.如果subRoot->data< node.data,需要递归下右子树，如果这个递归返回true,将subRoot的平衡因子调整为-1，如果为false就return false。

    B.subRoot->data > node.data需要递归下左子树，如果这个递归返回true,将subRoot的平衡因子调整为+1，如果为false就return false。

    C.subRoot->data == node.data.

          1）如果此时subRoot只有一个孩子或者没有孩子，那么删除时树高一定会改变。另外做一个简单的删除操作即可。该左孩子代替此节点还是右孩子代替它，如何代替其实和BinarySearchTree一样。再return true

          2）如果有两个孩子，去左子树中找到替代品，然后将这个subRoot的数据域完全变为此替代品后，去左子树中用再用deleteNode方法将替代品删除。如果deleteNode操作返回true，那么显然subRoot的平衡因子要加1.

3.如果subRoot的平衡因子已经为2或者-2，那么以subRoot为根开始调整。

    A.如果调整后subRoot平衡因子为0，return true

    B.不为0，return false。

 

 下面是实际代码

 

  1.     bool deleteNode(AVLNode<T>* subRoot, AVLNode<T>* prev, T& node)
  2.     {
  3.         if(subRoot == NULL)
  4.         {
  5.             return false;
  6.         }
  7.         bool isChangeHeight = false;
  8.         if(subRoot->getData() > node)
  9.         {
  10.             isChangeHeight = deleteNode(subRoot->getLeft(),subRoot,node);
  11.             if(isChangeHeight)
  12.             {
  13.                 subRoot->setAHeight(subRoot->getAHeight()+1);
  14.             }
  15.             
  16.         }
  17.         else if(subRoot->getData() < node)
  18.         {
  19.             isChangeHeight = deleteNode(subRoot->getRight(),subRoot,node);
  20.             if(isChangeHeight)
  21.             {
  22.                 subRoot->setAHeight(subRoot->getAHeight()-1);
  23.             }
  24.             
  25.         }
  26.         else
  27.         {
  28.             AVLNode<T>* assignNode = NULL;
  29.             if(subRoot->getLeft() == NULL && subRoot->getRight() == NULL)
  30.             {
  31.                 // no child
  33.                 isChangeHeight = true;
  34.                 deleteNode(subRoot,prev,assignNode);
  35.                 return isChangeHeight;
  36.             }
  37.             else if(subRoot->getLeft() == NULL && subRoot->getRight() != NULL)
  38.             {
  39.                 // no left child
  40.                 isChangeHeight = true;
  41.                 assignNode = subRoot->getRight();
  42.                 deleteNode(subRoot,prev,assignNode);
  43.                 return isChangeHeight;
  44.                 
  45.             }           
  46.             else if(subRoot->getRight() == NULL && subRoot->getLeft() != NULL)
  47.             {
  48.                 // no right chlid
  49.                 isChangeHeight = true;
  50.                 assignNode = subRoot->getLeft();
  51.                 deleteNode(subRoot,prev,assignNode);
  52.                 return isChangeHeight;
  53.             }
  54.             else
  55.             {
  56.                 // have both children 
  57.                 assignNode = getMaxNode(subRoot->getLeft());
  58.                 T data = assignNode->getData();
  59.                 bool isChange = deleteNode(subRoot->getLeft(),subRoot,data);
  60.                 cout << "use "<< data<< " replace "<< subRoot->getData()<<endl;
  61.                 subRoot->setData(data);// copy all data to subRoot
  62.                 
  63.                 if(isChange)
  64.                 {
  65.                     subRoot->setAHeight(subRoot->getAHeight()+1);
  66.                 }
  67.             }
  69.             if(subRoot->getAbsoluteAHeight() == 2)
  70.             {
  71.                 AVLNode<T>* a = subRoot;
  72.                 AVLNode<T>* b = NULL;
  73.                 AVLNode<T>* c = NULL;
  74.                 AVLNode<T>* tempRoot = NULL;
  75.                 if(subRoot->getAHeight() == 2)
  76.                 {
  77.                     // move to left 
  78.                     b = subRoot->getRight();
  79.                     switch(b->getAHeight())
  80.                     {
  81.                         case 1:
  82.                             tempRoot = RRRotate(a,b);
  83.                             isChangeHeight = true;
  84.                             break;
  85.                         case -1:
  86.                             c = b->getLeft();
  87.                             tempRoot = RLRotate(a,b,c);
  88.                             isChangeHeight = true;
  89.                             break;
  90.                         case 0:
  91.                             tempRoot = RRRotate(a,b);   
  92.                             isChangeHeight = false;
  93.                             break;
  94.                     }
  96.                 }
  97.                 else if(subRoot->getAHeight() == -2)
  98.                 {
  99.                     // move to right
  100.                     b = subRoot->getLeft();
  101.                     switch(b->getAHeight())
  102.                     {
  103.                         case 1:
  104.                             c = b->getRight();
  105.                             tempRoot = LRRotate(a,b,c);
  106.                             isChangeHeight = true;
  108.                             break;
  109.                         case -1:
  110.                             tempRoot = LLRotate(a,b);
  111.                             isChangeHeight = true;
  112.                             break;
  113.                         case 0:
  114.                             tempRoot = LLRotate(a,b);   
  115.                             isChangeHeight = false;
  116.                             break;
  117.                     }   
  119.                 }
  121.                 if(prev == NULL)
  122.                 {
  123.                     this->head = tempRoot;
  124.                 }
  125.                 else
  126.                 {
  127.                     if(prev->getData() > tempRoot->getData())
  128.                     {
  129.                         prev->setLeft(tempRoot);
  130.                     }
  131.                     else
  132.                     {
  133.                         prev->setRight(tempRoot);
  134.                     }
  135.                 }
  136.             }
  140.         }
  142.         return isChangeHeight;
  144.     }

最后贴上AVLTree的完整类代码

 

  1. #include "AVLNode.h"
  3. template<class T>
  4. class AVLTree
  5. {
  6. private:
  7.     AVLNode<T>* head;
  9.     int getHeight(AVLNode<T>* node)
  10.     {
  11.         if(node == NULL)
  12.         {
  13.             return 0;
  14.         }
  15.         else
  16.         {
  17.             int leftHeight = getHeight(node->getLeft());
  18.             int rightHeight = getHeight(node->getRight());
  19.             if(leftHeight > rightHeight)
  20.             {
  21.                 return leftHeight+1;
  22.             }
  23.             else
  24.             {
  25.                 return rightHeight+1;
  26.             }
  27.         }
  28.     }
  30.     int getAVLHeight(AVLNode<T>* node)
  31.     {
  32.         if(node == NULL)
  33.         {
  34.             return 0;
  35.         }
  36.         else
  37.         {
  38.             int leftHeight = getHeight(node->getLeft());
  39.             int rightHeight = getHeight(node->getRight());
  40.             return rightHeight - leftHeight;
  41.         }
  42.     }
  45.     void clearSubTree(AVLNode<T>* node)
  46.     {
  47.         if(node != NULL)
  48.         {
  49.             clearSubTree(node->getLeft());
  50.             clearSubTree(node->getRight());
  51.             delete node;
  52.         }
  53.     }
  55.     void printTree(AVLNode<T>* subTree, int count)
  56.     {
  57.         if(subTree!=NULL)
  58.         {
  59.             
  60.             printTree(subTree->getRight(), count+1);
  61.             for(int i = 0; i < count; i++)
  62.             {
  63.                 cout << "   ";
  64.             }
  65.             cout <<subTree->getData()<<endl;
  66.             printTree(subTree->getLeft(),count+1);
  67.         }
  68.     }
  71.     void printInMidOrder(AVLNode<T>* subTree)
  72.     {
  73.         if(subTree!=NULL)
  74.         {
  75.             printInMidOrder(subTree->getLeft());
  76.             
  78.             cout <<subTree->getData()<<endl;
  79.             printInMidOrder(subTree->getRight());
  80.         }
  81.     }
  83.     bool isPossibleNode(AVLNode<T>* node, AVLNode<T>* comNode)
  84.     {
  85.         if(node != NULL && node->getAbsoluteAHeight() == 1)
  86.         {
  87.             return true;
  88.         }
  89.         return false;
  90.     }
  92.     void insertNode(AVLNode<T>* node)
  93.     {
  94.         AVLNode<T>* subRoot = this->head;
  95.         if(subRoot == NULL)
  96.         {
  97.             subRoot = node;
  98.             return;
  99.         }
  100.         AVLNode<T>* ppoRoot = NULL;
  101.         AVLNode<T>* poRoot = NULL;
  102.         AVLNode<T>* pRoot = NULL;
  103.         
  104.     
  106.         poRoot = subRoot;
  107.         
  108.         while(subRoot != NULL)
  109.         {
  110.             pRoot = subRoot;
  111.             if(subRoot->getData() > node->getData())
  112.             {
  113.                 
  114.                 if(isPossibleNode(subRoot->getLeft(),node))
  115.                 {
  116.                     poRoot = subRoot->getLeft();
  117.                     ppoRoot = subRoot;
  118.                 }
  119.                 subRoot = subRoot->getLeft();
  121.             }
  122.             else if(subRoot->getData() < node->getData())
  123.             {
  124.                 
  125.                 if(isPossibleNode(subRoot->getRight(),node))
  126.                 {
  127.                     poRoot = subRoot->getRight();
  128.                     ppoRoot = subRoot;
  129.                 }
  130.                 subRoot = subRoot->getRight();
  131.             }
  132.             else
  133.             {
  134.                 throw "the same key";
  135.             }
  136.         }
  138.         bool isChangeHeight = false;
  139.         if(pRoot->getData() > node->getData())
  140.         {
  141.         
  142.             pRoot->setLeft(node);
  143.             if(pRoot->getRight() == NULL)
  144.             {
  145.                 isChangeHeight = true;
  146.             }
  147.             else
  148.             {
  149.                 pRoot->setAHeight(pRoot->getAHeight()-1);
  150.             }
  151.         }
  152.         else if(pRoot->getData() < node->getData())
  153.         {
  154.             
  155.             pRoot->setRight(node);
  156.             if(pRoot->getLeft() == NULL)
  157.             {
  158.                 isChangeHeight = true;
  159.             }
  160.             else
  161.             {
  162.                 pRoot->setAHeight(pRoot->getAHeight()+1);
  163.             }
  164.         }
  167.         if(poRoot != NULL && isChangeHeight)
  168.         {
  169.             // s->a update Height
  170.             subRoot = poRoot;
  171.             while(subRoot != node)
  172.             {
  173.                 if(subRoot->getData() > node->getData())
  174.                 {
  175.                     subRoot->setAHeight(subRoot->getAHeight()-1);
  176.                     
  177.                     subRoot = subRoot->getLeft();
  179.                 }
  180.                 else if(subRoot->getData() < node->getData())
  181.                 {
  182.                     subRoot->setAHeight(subRoot->getAHeight()+1);
  183.                     
  184.                     subRoot = subRoot->getRight();
  186.                 }
  188.             }
  190.             subRoot = poRoot;
  191.             AVLNode<T>* a = poRoot;
  192.             AVLNode<T>* b = NULL;
  193.             AVLNode<T>* c = NULL;
  194.             AVLNode<T>* tempRoot = NULL;
  195.             if(a->getAbsoluteAHeight() > 1)
  196.             {
  197.                 if(subRoot->getData() > node->getData())
  198.                 {
  199.                     b = subRoot->getLeft();
  200.                     if(a->getAHeight()* b->getAHeight() > 0)
  201.                     {
  202.                         //LLRotate
  203.                         tempRoot = LLRotate(a,b);
  204.                         
  205.                     }
  206.                     else
  207.                     {
  208.                         //LRRotate
  209.                         c = b->getRight();
  210.                         tempRoot =LRRotate(a,b,c);
  211.                     }
  212.                     
  213.                 }
  214.                 else if(subRoot->getData() < node->getData())
  215.                 {
  216.                     b = subRoot->getRight();
  217.                     if(a->getAHeight()* b->getAHeight() > 0)
  218.                     {
  219.                         //RRRotate
  220.                         tempRoot = RRRotate(a,b);
  221.                     }
  222.                     else
  223.                     {
  224.                         //RLRotate
  225.                         c = b->getLeft();
  226.                         tempRoot =RLRotate(a,b,c);
  227.                     }
  228.                 }
  229.                 if(ppoRoot!=NULL)
  230.                 {
  231.                     if(ppoRoot->getData() > tempRoot->getData())
  232.                     {
  233.                         ppoRoot->setLeft(tempRoot);
  234.                     }
  235.                     else
  236.                     {
  237.                         ppoRoot->setRight(tempRoot);
  238.                     }
  239.                 }
  240.                 else
  241.                 {
  242.                     this->head = tempRoot;
  243.                 }
  244.             }
  245.             
  247.         }
  249.     }
  252.     // return the subRoot
  253.     //        a                   b
  254.     //       /                  /   /
  255.     //      b        ->        c     a
  256.     //     /
  257.     //    c
  258.     AVLNode<T>* LLRotate(AVLNode<T>* a, AVLNode<T>* b)
  259.     {
  260.         a->setLeft(b->getRight());
  261.         b->setRight(a);
  262.         
  263.         a->setAHeight(0);
  264.         b->setAHeight(0);
  265.         //a->setAHeight(getAVLHeight(a));
  266.         //b->setAHeight(getAVLHeight(b));
  267.         return b;
  268.     }
  270.     // return the subRoot
  271.     //        a                      b
  272.     //          /                  /   /
  273.     //            b        ->     a     c
  274.     //              /
  275.     //                c
  276.     AVLNode<T>* RRRotate(AVLNode<T>* a, AVLNode<T>* b)
  277.     {
  278.         a->setRight(b->getLeft());
  279.         b->setLeft(a);
  280.         
  281.         a->setAHeight(0);
  282.         b->setAHeight(0);
  283.         //a->setAHeight(getAVLHeight(a));
  284.         //b->setAHeight(getAVLHeight(b));
  285.         return b;
  286.     }
  289.     // return the subRoot
  290.     //        a                      c
  291.     //          /                  /   /
  292.     //            b        ->     a     b
  293.     //           /                 /      
  294.     //          c                   d  
  295.     //         /
  296.     //        d
  297.     AVLNode<T>* RLRotate(AVLNode<T>* a, AVLNode<T>* b, AVLNode<T>* c)
  298.     {
  299.         
  300.         b->setLeft(c->getRight());
  301.         c->setRight(b);
  302.         a->setRight(c->getLeft());
  303.         c->setLeft(a);
  304.         
  305.         
  306.         //a->setAHeight(getAVLHeight(a));
  307.         //c->setAHeight(getAVLHeight(c));
  308.         //b->setAHeight(getAVLHeight(b));
  310.         if(c->getAbsoluteAHeight() == 1)
  311.         {
  312.             if(b->getAHeight() == 0)
  313.             {
  314.                 b->setAHeight(-1);
  315.             }
  316.             else
  317.             {
  318.                 b->setAHeight(0);
  319.             }
  320.             a->setAHeight(1);
  321.             c->setAHeight(0);
  322.         
  323.         }
  324.         else
  325.         {
  326.             if(b->getAHeight() == 0)
  327.             {
  328.                 b->setAHeight(-1);
  329.             }
  330.             else
  331.             {
  332.                 b->setAHeight(0);
  333.             }
  334.             a->setAHeight(0);
  335.             c->setAHeight(0);
  336.             
  337.         }
  338.         
  339.         
  340.         return c;
  341.     }
  343.     // return the subRoot
  344.     //        a                      c
  345.     //       /                     /   /
  346.     //      b              ->     b     a
  347.     //       /                         /       
  348.     //        c                       d   
  349.     //         /
  350.     //          d
  351.     AVLNode<T>* LRRotate(AVLNode<T>* a, AVLNode<T>* b, AVLNode<T>* c)
  352.     {
  353.         b->setRight(c->getLeft());
  354.         c->setLeft(b);
  355.         a->setLeft(c->getRight());
  356.         c->setRight(a);
  357.         
  358.         
  359.         //a->setAHeight(getAVLHeight(a));
  360.         //c->setAHeight(getAVLHeight(c));
  361.         //b->setAHeight(getAVLHeight(b));
  363.         if(c->getAbsoluteAHeight() == 1)
  364.         {
  365.             if(b->getAHeight() == 0)
  366.             {
  367.                 b->setAHeight(1);
  368.             }
  369.             else
  370.             {
  371.                 b->setAHeight(0);
  372.             }
  374.             a->setAHeight(-1);
  375.             c->setAHeight(0);
  376.             
  377.         }
  378.         else
  379.         {
  381.             if(b->getAHeight() == 0)
  382.             {
  383.                 b->setAHeight(1);
  384.             }
  385.             else
  386.             {
  387.                 b->setAHeight(0);
  388.             }
  389.             a->setAHeight(0);
  390.             c->setAHeight(0);
  391.         
  392.         }
  393.         
  394.         
  395.         
  397.         return c;
  398.     }
  401.     AVLNode<T>* getMaxNode(AVLNode<T>* subRoot)
  402.     {
  403.         if(subRoot == NULL)
  404.         {
  405.             return NULL;
  406.         }
  407.         if(subRoot->getRight() == NULL)
  408.         {
  409.             return subRoot;
  410.         }
  411.         else
  412.         {
  413.             return getMaxNode(subRoot->getRight());
  414.         }
  415.     }
  417.     void deleteNode(AVLNode<T>* subRoot, AVLNode<T>* prev,AVLNode<T>* assignNode)
  418.     {
  419.         if(prev == NULL)
  420.         {
  421.             this->head = assignNode;
  423.         }
  424.         else
  425.         {
  426.             if(prev->getLeft() == subRoot)
  427.             {
  428.                 prev->setLeft(assignNode);
  429.                 
  430.             }
  431.             else if(prev->getRight() == subRoot)
  432.             {
  433.                 prev->setRight(assignNode);
  434.                 
  435.             }
  436.         }
  437.         
  438.         delete subRoot;
  439.     }
  441.     bool deleteNode(AVLNode<T>* subRoot, AVLNode<T>* prev, T& node)
  442.     {
  443.         if(subRoot == NULL)
  444.         {
  445.             return false;
  446.         }
  447.         bool isChangeHeight = false;
  448.         if(subRoot->getData() > node)
  449.         {
  450.             isChangeHeight = deleteNode(subRoot->getLeft(),subRoot,node);
  451.             if(isChangeHeight)
  452.             {
  453.                 subRoot->setAHeight(subRoot->getAHeight()+1);
  454.             }
  455.             
  456.         }
  457.         else if(subRoot->getData() < node)
  458.         {
  459.             isChangeHeight = deleteNode(subRoot->getRight(),subRoot,node);
  460.             if(isChangeHeight)
  461.             {
  462.                 subRoot->setAHeight(subRoot->getAHeight()-1);
  463.             }
  464.             
  465.         }
  466.         else
  467.         {
  468.             AVLNode<T>* assignNode = NULL;
  469.             if(subRoot->getLeft() == NULL && subRoot->getRight() == NULL)
  470.             {
  471.                 // no child
  473.                 isChangeHeight = true;
  474.                 deleteNode(subRoot,prev,assignNode);
  475.                 return isChangeHeight;
  476.             }
  477.             else if(subRoot->getLeft() == NULL && subRoot->getRight() != NULL)
  478.             {
  479.                 // no left child
  480.                 isChangeHeight = true;
  481.                 assignNode = subRoot->getRight();
  482.                 deleteNode(subRoot,prev,assignNode);
  483.                 return isChangeHeight;
  484.                 
  485.             }           
  486.             else if(subRoot->getRight() == NULL && subRoot->getLeft() != NULL)
  487.             {
  488.                 // no right chlid
  489.                 isChangeHeight = true;
  490.                 assignNode = subRoot->getLeft();
  491.                 deleteNode(subRoot,prev,assignNode);
  492.                 return isChangeHeight;
  493.             }
  494.             else
  495.             {
  496.                 // have both children 
  497.                 assignNode = getMaxNode(subRoot->getLeft());
  498.                 T data = assignNode->getData();
  499.                 bool isChange = deleteNode(subRoot->getLeft(),subRoot,data);
  500.                 cout << "use "<< data<< " replace "<< subRoot->getData()<<endl;
  501.                 subRoot->setData(data);// copy all data to subRoot
  502.                 
  503.                 if(isChange)
  504.                 {
  505.                     subRoot->setAHeight(subRoot->getAHeight()+1);
  506.                 }
  507.             }
  509.             if(subRoot->getAbsoluteAHeight() == 2)
  510.             {
  511.                 AVLNode<T>* a = subRoot;
  512.                 AVLNode<T>* b = NULL;
  513.                 AVLNode<T>* c = NULL;
  514.                 AVLNode<T>* tempRoot = NULL;
  515.                 if(subRoot->getAHeight() == 2)
  516.                 {
  517.                     // move to left 
  518.                     b = subRoot->getRight();
  519.                     switch(b->getAHeight())
  520.                     {
  521.                         case 1:
  522.                             tempRoot = RRRotate(a,b);
  523.                             isChangeHeight = true;
  524.                             break;
  525.                         case -1:
  526.                             c = b->getLeft();
  527.                             tempRoot = RLRotate(a,b,c);
  528.                             isChangeHeight = true;
  529.                             break;
  530.                         case 0:
  531.                             tempRoot = RRRotate(a,b);   
  532.                             isChangeHeight = false;
  533.                             break;
  534.                     }
  536.                 }
  537.                 else if(subRoot->getAHeight() == -2)
  538.                 {
  539.                     // move to right
  540.                     b = subRoot->getLeft();
  541.                     switch(b->getAHeight())
  542.                     {
  543.                         case 1:
  544.                             c = b->getRight();
  545.                             tempRoot = LRRotate(a,b,c);
  546.                             isChangeHeight = true;
  548.                             break;
  549.                         case -1:
  550.                             tempRoot = LLRotate(a,b);
  551.                             isChangeHeight = true;
  552.                             break;
  553.                         case 0:
  554.                             tempRoot = LLRotate(a,b);   
  555.                             isChangeHeight = false;
  556.                             break;
  557.                     }   
  559.                 }
  561.                 if(prev == NULL)
  562.                 {
  563.                     this->head = tempRoot;
  564.                 }
  565.                 else
  566.                 {
  567.                     if(prev->getData() > tempRoot->getData())
  568.                     {
  569.                         prev->setLeft(tempRoot);
  570.                     }
  571.                     else
  572.                     {
  573.                         prev->setRight(tempRoot);
  574.                     }
  575.                 }
  576.             }
  580.         }
  582.         return isChangeHeight;
  584.     }
  586.     
  588. public:
  589.     AVLTree(T& data)
  590.     {
  591.         head = new AVLNode<T>(data);
  592.     }
  594.     AVLTree(AVLNode<T>* head)
  595.     {
  596.         clearSubTree(this->head);
  597.         this->head = head;
  598.     }
  600.     ~AVLTree()
  601.     {
  602.         clearSubTree(head);
  603.     }
  605.     void printTree()
  606.     {
  607.         printTree(this->head,0);
  608.     }
  610.     void printInMidOrder()
  611.     {
  612.         printInMidOrder(this->head);
  613.     }
  616.     void insertNode(T& data)
  617.     {
  618.         insertNode(new AVLNode<T>(data));
  620.     }
  622.     void deleteNode(T& data)
  623.     {
  624.         deleteNode(this->head,NULL,data);
  625.     }
  626.     /*bool isUnbalancePoint(AVLNode<T>* node, AVLNode<T>* compareNode)
  627.     {
  629.         if(node->getAbsoluteAHeight() == 1)
  630.         {
  632.             if(node->getAHeight == 1 && node->getData() < compareNode->getData() )
  633.             {
  634.                 return true;
  635.             }
  636.             else if(node->getAHeight == -1 && node->getData() > compareNode->getData())
  637.             {
  638.                 return true;
  639.             }
  640.         }
  641.         return false;
  642.     }*/
  645. };
帐前卒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2024 数据结构（浙大慕课）PAT题 —— 第一部分
weixin_45939751的博客
03-26 1846
函数题 01-复杂度3 二分查找（分数20） 题目要求 本题要求实现二分查找算法 函数接口定义： Position BinarySearch( List L, ElementType X ); List结构定义如下： typedef int Position; typedef struct LNode *List; struct LNode { ElementType Data[MAXSIZE]; Position Last; /* 保存线性表中最后一个元素的位置 */ }; L是用户传
AVLTree.zip_平衡树
09-14
在IT领域，平衡树是一种非常重要的数据结构，它在存储和检索数据时能保持高度的效率。本项目涉及的是AVL树，一种自平衡的二叉搜索树（Binary Search Tree, BST），由G. M. Adelson-Velsky和E. M. Landis于1962年提出...
数据结构——树的定义与性质
zhu_liucheng的博客
07-24 1817
树的定义与性质1 定义1.1 树型结构1.2 树的递归嵌套定义2 基本术语3 类型3.1 二叉树3.1.1 定义3.1.2 特点3.1.3 性质3.2 满二叉树3.2.1 定义3.2.2 特点3.2.3 性质3.3 完全二叉树3.3.1 定义3.3.2 特点3.3.3 性质3.4 二叉排序树（非重点）3.4.1 定义3.4.2 性质3.5 平衡二叉树（非重点）3.5.1 定义3.5.2 性质4 应用 1 定义 1.1 树型结构 （1）结点之间有分支 （2）具有层次关系 1.2 树的递归嵌套定义 树（tree
【数据结构】6.4 AVL树（C++）
weixin_52811588的博客
04-10 1637
AVL树是一个接近平衡的二叉搜索树，解决了普通二叉搜索树的单支问题造成的查找效率降低。这里非常详细的描述了AVL树的结构和构造过程，并且使用了C++语法实现了AVL树，欢迎大家参考和阅读
瑞_数据结构与算法_二叉搜索树
最新发布
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
01-25 1262
本文章为瑞_系列专栏之《数据结构与算法》的二叉搜索树篇。
超硬核十万字！全网最全 数据结构 代码，随便秒杀老师/面试官，我说的
热门推荐
hebtu666
04-20 11万+
本文代码实现基本按照《数据结构》课本目录顺序，外加大量的复杂算法实现，一篇文章足够。能换你一个收藏了吧？
PTA写BUG日志——关于数据结构里面的“树”（算法笔记上机实战）
糕糕的博客
08-16 177
二叉树的遍历 先序遍历 中序遍历 后序遍历 层序遍历 经典问题1：给出两个遍历树的序列，如何复现树？???? 答：一定会需要中序遍历来区分左右子树，中序遍历+（剩余3种任一遍历的数组即可复现原来的树的结构） 练习1 PTA甲级1020 这题是根据中序和后序来复现树的结构，再用层次遍历输出即可，思路不是特别难，主要涉及复现函数create以及层次遍历函数levelTravel 复现函数《算法笔记》给了先序+中序的版本，可以参考画图加深理解 //1020 #include<bits/stdc+
只有程序员看的懂面试圣经｜如何拿下编程面试
skysky01的专栏
10-12 1620
当我最初开始参加编程面试的时候，我所有最心仪的公司都忽视了我。现在回头看那个时候，我发现自己当时去参加面试都完全没做任何准备。虽然已经有许多博客文章和书籍在讲编程面试，但现在的我作为面试官，坐在桌子的另一边，还是能看到许多来参加编程面试的人没做任何准备，或者准备得很糟糕。这也就是为什么我开始写这篇指南的原因，刚毕业时的我、第一次参加面试的我一定非常想有这么一份指南来指引自己。而从现在开始，我自己也
sed 详解 & red-black-tree
happylzs2008的专栏
04-26 218
有没有大神帮忙解释下Sed 命令的r参数的用法，最好带例子 https://zhidao.baidu.com/question/430870483731546652.html sed指令使用详解 https://blog.csdn.net/Primeprime/article/details/108891452?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-1&spm=1001.2101.3001.4242 sed之
AVLtree_c_avl_平衡二叉树_avltree_
10-02
综上所述，"AVLtree_c_avl_平衡二叉树_avltree_"这个项目可能是用C语言实现了一个AVL树的数据结构，并提供了对树的增删改查操作，同时具备用户友好的交互界面。这个项目对于理解和实践AVL树的概念、操作和性能优化...
avl.rar_avl_平衡树
09-20
3. **插入操作**：在AVL树中插入新节点时，可能需要进行一次或多次旋转来重新平衡树。首先，像普通BST那样插入节点，然后检查新插入节点及其祖先节点的平衡因子，根据情况进行相应的旋转。 4. **删除操作**：删除...
AvlTree.rar_AVL树
09-19
在“AvlTree.rar”压缩包中，可能包含AVL树的实现代码示例，包括基础的AVL树结构以及经过改进的AVL树结构，例如可能有C++、Java或Python的代码实现。通过这些示例，你可以学习如何创建、插入、删除节点以及进行平衡...
avl_tree.zip_AVL树_avl_tree
09-21
4. 插入和删除：插入和删除操作可能导致树的不平衡，需要通过旋转来重新平衡树。插入操作可能需要进行单旋转或双旋转，删除操作相对复杂，可能涉及替换、删除节点和重新平衡等多个步骤。 C++实现AVL树时，通常包括...
c++ 类中static变量初始化问题
帐前卒 专栏
03-11 2万+
 首先static变量只有一次初始化，不管在类中还是在函数中..有这样一个函数：void Foo(){ static int a=3; // initialize std::cout << a; a++;} 这里的static int a=3只执行了一次。在main中调用Foo()两次，结果为34.将上面的函数改为void Foo(){ static in
expected primary-expression before "double"
帐前卒 专栏
01-04 1万+
如果你定义了个模板函数例如：templatevoid write(fstream & f, T &a){ ....} 那么在调用时写write(f,a); 就有可能出现expected primary-expression before "double"的错误。这是因为有可能有的头文件中有write这个函数，并且它不是模板函数，那么就会导致expected p
elf file OS ABI invalid
帐前卒 专栏
08-28 1万+
昨天调用第三方库的JNI时发现如下问题：elf file OS ABI invalid问题出自ldd，先看一下ldd的版本号。使用： ldd --version这个问题是因为在ldd 为2.12的机器上编译。拿到ldd 为2.5的机器上去运行加载，然后就挂掉了。解决方法就是使用ldd 2.5的机器编译。
yacc lex 使用中错误信息解决解决方案
帐前卒 专栏
03-18 1万+
 ex3.y: In function ‘yyerror’:ex3.y:32: warning: incompatible implicit declaration of built-in function ‘printf’这一条是因为.y缺少头文件。在.y文件中需要在%{....%}之中写入#include 等头文件。如果只有printf那就只用这个头文件就行了。  ex
04-二叉平衡树1 Root of AVL Tree
06-12
如果我们在进行插入或删除操作时，根节点的平衡性被破坏了，那么我们可以通过旋转操作来恢复平衡，使得根节点重新成为平衡树的根节点。因此，根节点的位置是可以动态变化的，取决于树的结构和节点的插入删除操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值