AVL树（C++模块实现）

于 2013-03-21 11:56:58 发布
阅读量490 收藏
点赞数
分类专栏： C++学习---------数据结构 文章标签： C++数据结构 堆栈 队列 AVL树

AVL树又叫自平衡二叉查找树，在效率上不比红黑树，但是是红黑树的基础！下面是构造一棵AVL树的完整代码！

  1. //AVLTree.h
  2. //参考：http://www.cppblog.com/goodwin/archive/2011/08/08/152797.html

  4. #ifndef _AVLTREE_H_
  5. #define _AVLTREE_H_

  7. #include "Stack.h"
  8. #include "Queue.h"
  9. #define SAFE_CALL(p) p == NULL ? NULL : p
  10. template <typename T>
  11. T Max(T a,T b)
  12. {
  13.     return (a)>(b) ? (a) : (b);
  14. }

  16. namespace _AVL_Tree_
  17. {
  18.     #define Balance(a)    abs((SAFE_CALL(a->mpLeft)->mHeigh) - (SAFE_CALL(a->mpRight)->mHeigh))
  19.     #define isLeftHigh(a)    ((SAFE_CALL(a->mpLeft)->mHeigh) > (SAFE_CALL(a->mpRight)->mHeigh)) ? true : false
  20.     #define isLeftTree(a,b) ((a)->mpLeft == (b)) ? true : false
  21. #define isRightTree(a,b) ((a)->mpRight == (b)) ? true : false

  23.     typedef enum _position_
  24.     {
  25.         enPosi_Root = 0,
  26.         enPosi_Left,
  27.         enPosi_Right,
  28.         enPosi_Equal,
  29.         enPosiMax
  30.     }POSITION;

  32.     typedef enum _rotal_type_
  33.     {
  34.         enRotalType_Anonymous,
  35.         enRotalType_LeftLeft = 1,
  36. enRotalType_RightRight,
  37.         enRotalType_LeftRight,
  38.         enRotalType_RightLeft,
  39.         enRotalType_MaxType
  40.     }RotalType;

  42.     template <typename T>
  43.     class TreeNode
  44.     {
  45.     public:
  46.         TreeNode()
  47.         {
  48.             mHeigh    = 0;
  49.             mElement = T();
  50.             mpLeft = mpRight = mpParent = NULL;
  51.         }
  52.         ~TreeNode()
  53.         {
  54.             mElement = T();
  55.             mpLeft = mpRight = mpParent = NULL;
  56.         }
  57.         T                mElement;
  58.         int            mHeigh;
  59.         TreeNode<T>*    mpLeft;
  60.         TreeNode<T>*    mpRight;
  61.         TreeNode<T>*    mpParent;
  62.     };

  64.     template <typename T>
  65.     class AVLTree
  66.     {
  67.     public:
  68.         AVLTree();
  69.         ~AVLTree();

  71.         bool    insert(const T& element);
  72.         bool    remove(const T& element);
  73.         bool clear();
  74.         //POSITION:返回找到的插入点的位置，s:返回在遍历过程中从树根到找到的插入点的路径（主要是用来旋转用）。
  75.         POSITION find(const T& element,Stack<TreeNode<T>*>& s);
  76.         //中序遍历
  77.         bool inorderTravel(void);

  79.         //先序遍历
  80.         bool prevorederTravel(void);

  82.         //中序遍历,并把遍历的结果放到栈中，用户销毁这棵树。
  83.         bool inorderTravel(Stack<TreeNode<T>*>& s);

  85.         //求一棵树的最大长度的路径。
  86.         bool getLongestPath(const TreeNode<T>* pRoot,Queue<TreeNode<T>*>& q);

  88.         //检查是否是AVL树。
  89.         bool checkIsAVLTree(void);

  91.         //把AVL树的信息丰收放到文件中
  92.         void saveAVLTreeToFile(const char* pFileName);

  94.     protected:
  95.         TreeNode<T>* CreateNode(const T& element);
  96.         TreeNode<T>* RightRightRotal(TreeNode<T>* pNode);
  97.         TreeNode<T>* LeftLeftRotal(TreeNode<T>* pNode);
  98.         TreeNode<T>* LeftRightRotal(TreeNode<T>* pNode);
  99.         TreeNode<T>* RightLeftRotal(TreeNode<T>* pNode);
  100.         RotalType checkRotalType(TreeNode<T>* pPParentNode,TreeNode<T>* pParentNode,TreeNode<T>* pNode);
  101.         TreeNode<T>* rotalTree(TreeNode<T>* pPParentNode,TreeNode<T>* pParentNode,TreeNode<T>* pNode);
  102.         //当要进行旋转时，判定需求旋转的类型。
  103.         RotalType checkRotalType(TreeNode<T>* pRootNode);
  104.         //对以pRootNode为根的进行旋转
  105.         TreeNode<T>* rotalTree(TreeNode<T>* pRootNode);
  106.         //对树进行平衡处理
  107.         bool balanceTree(TreeNode<T>* pRootNode);

  109.         //获取节点pNode的中序遍历【前驱】节点
  110.         TreeNode<T>* getPrevNode(TreeNode<T>* pNode);
  111.         //获取节点pNode的中序遍历【后继】节点
  112.         TreeNode<T>* getNextNode(TreeNode<T>* pNode);
  113.     private:
  114.         TreeNode<T>* mpRoot;
  115.     };

  117.     template <typename T>
  118.     AVLTree<T>::AVLTree()
  119.     {
  120.         mpRoot = new TreeNode<T>;
  121.         if (!mpRoot) throw("malloc memery failed.");
  122.         mpRoot->mElement = -1;
  123.         mpRoot->mHeigh = 0;
  124.         mpRoot->mpLeft = mpRoot->mpParent = mpRoot->mpRight = NULL;
  125.     }
  126.     template <typename T>
  127.     AVLTree<T>::~AVLTree()
  128.     {
  129.         this->clear();
  130.         delete this->mpRoot;
  131.         this->mpRoot = NULL;
  132.     }

  134.     template <typename T>
  135.     TreeNode<T>* AVLTree<T>::CreateNode(const T& element)
  136.     {
  137.         TreeNode<T>* pNode = new TreeNode<T>;
  138.         if (pNode)
  139.         {
  140.             pNode->mElement    = element;
  141.             pNode->mpLeft    = pNode->mpRight = pNode->mpParent    = NULL;
  142.             pNode->mHeigh    = 1;
  143.             return pNode;
  144.         }
  145.         return NULL;
  146.     }

  148.     template <typename T>
  149.     TreeNode<T>* AVLTree<T>::RightRightRotal(TreeNode<T>* pNode)
  150.     {
  151.         TreeNode<T>* pRightChild = pNode->mpRight;
  152.         //cout << "RightRightRotal mElement:" << pNode->mElement << endl;
  153.         pNode->mHeigh    = Max((SAFE_CALL(pNode->mpLeft)->mHeigh),(SAFE_CALL(pRightChild->mpLeft)->mHeigh)) + 1;
  154.         pRightChild->mHeigh = Max((SAFE_CALL(pRightChild->mpRight)->mHeigh),(pNode->mHeigh)) + 1;

  156.         pNode->mpRight = pRightChild->mpLeft;
  157.         if (pRightChild->mpLeft && pRightChild->mpLeft->mpParent)
  158.         {
  159.             pRightChild->mpLeft->mpParent = pNode;
  160.         }
  161.         pRightChild->mpLeft = pNode;
  162.         pNode->mpParent = pRightChild;
  163.         return pRightChild;
  164.     }

  166.     template <typename T>
  167.     TreeNode<T>* AVLTree<T>::LeftLeftRotal(TreeNode<T>* pNode)
  168.     {
  169.         TreeNode<T>* pLeftChild = pNode->mpLeft;
  170.         //cout << "LeftLeftRotal mElement:" << pNode->mElement << endl;
  171.         pNode->mHeigh    = Max((SAFE_CALL(pLeftChild->mpRight)->mHeigh),(SAFE_CALL(pNode->mpRight)->mHeigh)) + 1;
  172.         pLeftChild->mHeigh = Max((SAFE_CALL(pLeftChild->mpLeft)->mHeigh),pNode->mHeigh) + 1;

  174.         pNode->mpLeft = pLeftChild->mpRight;
  175.         if (pLeftChild->mpRight && pLeftChild->mpRight->mpParent)
  176.         {
  177.             pLeftChild->mpRight->mpParent = pNode;
  178.         }
  179.         pLeftChild->mpRight = pNode;
  180.         pNode->mpParent = pLeftChild;
  181.         return pLeftChild;
  182.     }

  184.     template <typename T>
  185.     TreeNode<T>* AVLTree<T>::LeftRightRotal(TreeNode<T>* pNode)
  186.     {
  187.         TreeNode<T>* pLeftChild = pNode->mpLeft;
  188.         TreeNode<T>* pTmp        = pLeftChild;
  189.         //左旋转
  190.         pLeftChild = this->RightRightRotal(pLeftChild);
  191.         pNode->mpLeft = pLeftChild;

  193.         pLeftChild->mpParent = pNode;
  194.         pTmp->mpParent = pLeftChild;
  195.         //右旋转
  196.         pNode =this->LeftLeftRotal(pNode);
  197.         return pNode;
  198.     }

  200.     template <typename T>
  201.     TreeNode<T>* AVLTree<T>::RightLeftRotal(TreeNode<T>* pNode)
  202.     {
  203.         TreeNode<T>* pRightChild = pNode->mpRight;
  204.         TreeNode<T>* pTmp        = pRightChild;
  205.         //右旋转
  206.         pRightChild = this->LeftLeftRotal(pRightChild);
  207.         pNode ->mpRight = pRightChild;
  208.        
  209.         pRightChild->mpParent = pNode;
  210.         pTmp->mpParent = pRightChild;
  211.         //左旋转
  212.         pNode = this->RightRightRotal(pNode);
  213.         return pNode;
  214.     }

  216.     template <typename T>
  217.     RotalType AVLTree<T>::checkRotalType(TreeNode<T>* pPParentNode,TreeNode<T>* pParentNode,TreeNode<T>* pNode)
  218.     {
  219.         bool bPLeft = false,bLeft = false;
  220.         if (pPParentNode->mpLeft == pParentNode)
  221.             bPLeft = true;
  222.         else
  223.             bPLeft = false;

  225.         if (pParentNode->mpLeft == pNode)
  226.             bLeft = true;
  227.         else
  228.             bLeft = false;

  230.         RotalType type ;
  231.         if (bPLeft && bLeft)
  232.             type = enRotalType_LeftLeft;
  233.         else if (!bPLeft && bLeft)
  234.             type = enRotalType_RightLeft;
  235.         else if(bPLeft && !bLeft)
  236.             type = enRotalType_LeftRight;
  237.         else if (!bPLeft && !bLeft )
  238.             type = enRotalType_RightRight;
  239.         return type;
  240.     }

  242.     template <typename T>
  243.     TreeNode<T>* AVLTree<T>::rotalTree(TreeNode<T>* pPParentNode,TreeNode<T>* pParentNode,TreeNode<T>* pNode)
  244.     {
  245.         RotalType type = this->checkRotalType(pPParentNode,pParentNode,pNode);
  246.         switch (type)
  247.         {
  248.         case enRotalType_LeftLeft:
  249.             {
  250.                 return this->LeftLeftRotal(pPParentNode);
  251.             }
  252.         case enRotalType_RightRight:
  253.             {
  254.                 return this->RightRightRotal(pPParentNode);
  255.                 break;
  256.             }
  257.         case enRotalType_LeftRight:
  258.             {
  259.                 return this->LeftRightRotal(pPParentNode);
  260.                 break;
  261.             }
  262.         case enRotalType_RightLeft:
  263.             {
  264.                 return this->RightLeftRotal(pPParentNode);
  265.                 break;
  266.             }
  267.         }
  268.         return NULL;
  269.     }

  271.     //当要进行旋转时，判定需求旋转的类型。
  272.     template <typename T>
  273.     RotalType AVLTree<T>::checkRotalType(TreeNode<T>* pRootNode)
  274.     {
  275.         RotalType type = enRotalType_Anonymous;
  276.         if (Balance(pRootNode) >= 2)
  277.         {
  278.             bool bCLeft = false,bCCLeft = false;
  279.             Queue<TreeNode<T>*> q;
  280.             this->getLongestPath(pRootNode,q);

  282.             TreeNode<T>* pChildNode = q.front();    //先把树根出列
  283.             pChildNode= q.front();
  284.             bCLeft = (pRootNode->mpLeft == pChildNode);
  285.             TreeNode<T>* pCChildNode = q.front();
  286.             bCCLeft = (pChildNode->mpLeft == pCChildNode);
  287.             q.clear();
  288.             if (bCLeft && bCCLeft)
  289.                 type = enRotalType_LeftLeft;
  290.             else if (!bCLeft && bCCLeft)
  291.                 type = enRotalType_RightLeft;
  292.             else if(bCLeft && !bCCLeft)
  293.                 type = enRotalType_LeftRight;
  294.             else if (!bCLeft && !bCCLeft )
  295.                 type = enRotalType_RightRight;
  296.         }
  297.         return type;
  298.     }
  299.    
  300.     //对以pRootNode为根的进行旋转
  301.     template <typename T>
  302.     TreeNode<T>* AVLTree<T>::rotalTree(TreeNode<T>* pRootNode)
  303.     {
  304.         RotalType type = this->checkRotalType(pRootNode);

  306.         switch (type)
  307.         {
  308.         case enRotalType_Anonymous:
  309.             {
  310.                 return NULL;
  311.             }
  312.         case enRotalType_LeftLeft:
  313.             {
  314.                 return this->LeftLeftRotal(pRootNode);
  315.             }
  316.         case enRotalType_RightRight:
  317.             {
  318.                 return this->RightRightRotal(pRootNode);
  319.             }
  320.         case enRotalType_LeftRight:
  321.             {
  322.                 return this->LeftRightRotal(pRootNode);
  323.             }
  324.         case enRotalType_RightLeft:
  325.             {
  326.                 return this->RightLeftRotal(pRootNode);
  327.             }
  328.         }
  329.         return NULL;       
  330.     }

  332.     //对树进行平衡处理
  333.     template <typename T>
  334.     bool AVLTree<T>::balanceTree(TreeNode<T>* pRootNode)
  335.     {
  336.         while (pRootNode && pRootNode != this->mpRoot)
  337.         {
  338.             pRootNode->mHeigh = Max((SAFE_CALL(pRootNode->mpLeft)->mHeigh) , (SAFE_CALL(pRootNode->mpRight)->mHeigh)) + 1;
  339.             if (Balance(pRootNode) >= 2)
  340.             {
  341.                 bool bLeft = false;
  342.                 TreeNode<T>* pPPNode = pRootNode->mpParent;
  343.                 bLeft = (pPPNode->mpLeft == pRootNode);
  344.                 pRootNode = this->rotalTree(pRootNode);
  345.                 if (bLeft)
  346.                     pPPNode->mpLeft = pRootNode;
  347.                 else
  348.                     pPPNode->mpRight = pRootNode;
  349.                 pRootNode->mpParent = pPPNode;

  351.             }
  352.             pRootNode = pRootNode->mpParent;
  353.         }
  354.         return true;
  355.     }

  357.     //获取节点pNode的中序遍历【前驱】节点
  358.     template <typename T>
  359.     TreeNode<T>* AVLTree<T>::getPrevNode(TreeNode<T>* pNode)
  360.     {
  361.         TreeNode<T>* pTmpNode = pNode->mpLeft;
  362.         while (pTmpNode && pTmpNode->mpRight)
  363.             pTmpNode = pTmpNode->mpRight;
  364.         return pTmpNode;           
  365.     }

  367.     //获取节点pNode的中序遍历【后继】节点
  368.     template <typename T>
  369.     TreeNode<T>* AVLTree<T>::getNextNode(TreeNode<T>* pNode)
  370.     {
  371.         TreeNode<T>* pTmpNode = pNode->mpRight;
  372.         while (pTmpNode && pTmpNode->mpLeft)
  373.             pTmpNode = pTmpNode->mpLeft;
  374.         return pTmpNode;
  375.     }

  377.     template <typename T>
  378.     bool    AVLTree<T>::insert(const T& element)
  379.     {
  380.         TreeNode<T>* pNode = NULL;
  381.         TreeNode<T>* pInNode    = NULL;    //插入点节点
  382.         Stack<TreeNode<T>*> s;
  383.         POSITION pos = this->find(element,s);
  384.         switch (pos)
  385.         {
  386.         case enPosi_Equal:
  387.             {
  388.                 static int iCount = 0;
  389.                 cout << "----enPosi_Equal--iCount:"<<++iCount<<"--element:"<< element << endl;               
  390.                 break;
  391.             }
  392.         case enPosi_Root:
  393.             {
  394.                 pNode = this->CreateNode(element);
  395.                 this->mpRoot->mpLeft    = pNode;
  396.                 pNode->mpParent = this->mpRoot;
  397.                 break;
  398.             }
  399.         case enPosi_Left:
  400.             {
  401.                 pNode = this->CreateNode(element);
  402.                 pInNode = s.pop();
  403.                 pInNode->mpLeft = pNode;
  404.                 pNode->mpParent = pInNode;
  405.                 pInNode->mHeigh = Max((SAFE_CALL(pInNode->mpLeft)->mHeigh) ,(SAFE_CALL(pInNode->mpRight)->mHeigh)) + 1;
  406.                 TreeNode<T>* pParentNode = pInNode->mpParent;
  407.                 if (pParentNode && pParentNode != this->mpRoot)
  408.                 {
  409.                     this->balanceTree(pParentNode);
  410.                 }
  411.                 break;
  412.             }
  413.         case enPosi_Right:
  414.             {
  415.                 pNode = this->CreateNode(element);
  416.                 TreeNode<T>* pInNode = s.pop();
  417.                 pInNode->mpRight = pNode;
  418.                 pNode->mpParent = pInNode;

  420.                 pInNode->mHeigh = Max((SAFE_CALL(pInNode->mpRight)->mHeigh) , (SAFE_CALL(pInNode->mpLeft)->mHeigh)) + 1;
  421.                 TreeNode<T>* pParentNode = pInNode->mpParent;
  422.                 if (pParentNode && pParentNode != this->mpRoot)
  423.                 {
  424.                     this->balanceTree(pParentNode);
  425.                 }
  426.                 break;
  427.             }       
  428.         }
  429.         s.clear();
  430.         return true;
  431.     }

  433.     template <typename T>
  434.     bool AVLTree<T>::remove(const T& element)
  435.     {
  436.         TreeNode<T>* pDelNode    = NULL;    //插入点节点
  437.         Stack<TreeNode<T>*> s;
  438.         POSITION pos = this->find(element,s);
  439.         if (s.isEmpty())    goto OVER;
  440.         switch (pos)
  441.         {
  442.         case enPosi_Equal:
  443.             {
  444.                 pDelNode = s.pop();
  445.                 if (pDelNode->mpLeft == NULL && pDelNode->mpRight == NULL)
  446.                 {//1.删除的节点没有子树
  447.                     TreeNode<T>* pParentNode = pDelNode->mpParent;
  448.                     if (pParentNode && isLeftTree(pParentNode,pDelNode))
  449.                         pParentNode->mpLeft = NULL;
  450.                     else if(pParentNode && isRightTree(pParentNode,pDelNode))
  451.                         pParentNode->mpRight = NULL;

  453.                     this->balanceTree(pParentNode);

  455.                     delete pDelNode;
  456.                     pDelNode = NULL;
  457.                 }
  458.                 else if((pDelNode->mpLeft && pDelNode->mpRight == NULL) ||
  459.                     (pDelNode->mpLeft == NULL && pDelNode->mpRight))
  460.                 {//2.删除的节点有一子树
  461.                     TreeNode<T>* pChildNode = pDelNode->mpLeft;
  462.                     if(!pChildNode)
  463.                         pChildNode = pDelNode->mpRight;
  464.                     TreeNode<T>* pParentNode = pDelNode->mpParent;
  465.                     if (pParentNode && isLeftTree(pParentNode,pDelNode))
  466.                     {//    2.1、删除的结点是其父节点的左子树
  467.                         pParentNode->mpLeft = pChildNode;
  468.                         pChildNode->mpParent = pParentNode;
  469.                         this->balanceTree(pParentNode);
  470.                     }
  471.                     else if(pParentNode && isRightTree(pParentNode,pDelNode))
  472.                     {//2.2、删除的结点是其父节点的右子树
  473.                         pParentNode->mpRight = pChildNode;
  474.                         pChildNode->mpParent = pParentNode;
  475.                         this->balanceTree(pParentNode);
  476.                     }
  477.                     delete pDelNode;
  478.                     pDelNode = NULL;
  479.                 }
  480.                 else if (pDelNode->mpLeft && pDelNode->mpRight)
  481.                 {//3、删除的节点有左右子树
  482.                     /*
  483.                     有两种做法，要删除p的节点：
  484.                     1.把p的左子树设成其父节点的左子树，把p的右子树设成其实左子树的最右边的叶子节点。
  485.                     2.把p的【直接前驱（中序）】替换p，然后把【前驱】的左子树替换成【前驱】的右子树。
  486.                     以下实现是利用第2种方法。
  487.                     */
  488.                     if (pDelNode->mpLeft->mHeigh >= pDelNode->mpRight->mHeigh)
  489.                     {//左子树比右子树高，就用pDelNode的【前驱】替换
  490.                         TreeNode<T>* pPrevNode = this->getPrevNode(pDelNode);
  491.                         pDelNode->mElement = pPrevNode->mElement;

  493.                         TreeNode<T>* pParentNode = pPrevNode->mpParent;
  494.                         pParentNode->mpRight = pPrevNode->mpLeft;
  495.                         if (pPrevNode->mpLeft)
  496.                             pPrevNode->mpLeft->mpParent = pParentNode;
  497.                        
  498.                         this->balanceTree(pParentNode);

  500.                         delete pPrevNode;
  501.                         pPrevNode = NULL;
  502.                     }
  503.                     else
  504.                     {//右子树比左子树高，就用pDelNode的【后继】替换
  505.                         TreeNode<T>* pNextNode = this->getNextNode(pDelNode);
  506.                         pDelNode->mElement = pNextNode->mElement;

  508.                         TreeNode<T>* pParentNode = pNextNode->mpParent;
  509.                         pParentNode->mpLeft = pNextNode->mpRight;

  511.                         if(pNextNode->mpRight)
  512.                             pNextNode->mpRight->mpParent = pParentNode;

  514.                         this->balanceTree(pParentNode);

  516.                         delete pNextNode;
  517.                         pNextNode = NULL;
  518.                     }
  519.                 }
  520.                 break;
  521.             }
  522.         default:
  523.             {
  524.                 goto OVER;
  525.                 break;
  526.             }
  527.         }
  528. OVER:
  529.         s.clear();
  530.         return true;
  531.     }

  533.     template <typename T>
  534.     bool AVLTree<T>::clear()
  535.     {
  536.         Stack<TreeNode<T>*> s;

  538.         this->inorderTravel(s);
  539.         TreeNode<T>* pNode = NULL;
  540.         while ((pNode= s.pop()) != NULL)           
  541.             delete pNode;
  542.         return true;
  543.     }

  545.     //POSITION:返回找到的插入点的位置，s:返回在遍历过程中从树根到找到的插入点的路径（主要是用来旋转用）。
  546.     template <typename T>
  547.     POSITION AVLTree<T>::find(const T& element,Stack<TreeNode<T>* >& s)
  548.     {
  549.         TreeNode<T>* pNode = this->mpRoot->mpLeft;
  550.         POSITION pos = enPosi_Root;
  551.         while (pNode)
  552.         {
  553.             s.push(pNode);
  554.             if (element == pNode->mElement)
  555.             {
  556.                 pos = enPosi_Equal;
  557.                 break;
  558.             }
  559.             else if (element < pNode->mElement)
  560.             {
  561.                 pos = enPosi_Left;
  562.                 if (pNode->mpLeft)
  563.                     pNode = pNode->mpLeft;
  564.                 else
  565.                     break;           
  566.             }
  567.             else if (element > pNode->mElement)
  568.             {               
  569.                 pos = enPosi_Right;
  570.                 if (pNode->mpRight)
  571.                     pNode = pNode->mpRight;   
  572.                 else
  573.                     break;                           
  574.             }           
  575.         }
  576.         return pos;
  577.     }
  578.     //中序遍历
  579.     template <typename T>
  580.     bool AVLTree<T>::inorderTravel(void)
  581.     {
  582.         TreeNode<T>* pNode = this->mpRoot->mpLeft;
  583.         if (pNode)
  584.         {
  585.             Stack<TreeNode<T>*> s;
  586.             while (pNode || !s.isEmpty())
  587.             {
  588.                 while (pNode)
  589.                 {
  590.                     s.push(pNode);
  591.                     pNode = pNode->mpLeft;
  592.                 }
  593.                 pNode = s.pop();
  594.                 if (pNode)
  595.                 {
  596.                     cout << pNode->mElement << " ";
  597.                     pNode = pNode->mpRight;
  598.                 }               
  599.             }
  600.         }
  601.         return true;
  602.     }

  604.     //先序遍历
  605.     template <typename T>
  606.     bool AVLTree<T>::prevorederTravel(void)
  607.     {
  608.         TreeNode<T>* pNode = this->mpRoot->mpLeft;
  609.         if (pNode)
  610.         {
  611.             Stack<TreeNode<T>*> s;
  612.             while (pNode || !s.isEmpty())
  613.             {           
  614.                 while (pNode)
  615.                 {
  616.                     cout << pNode->mElement << " ";
  617.                     s.push(pNode);
  618.                     pNode = pNode->mpLeft;
  619.                 }
  620.                 pNode = s.pop();
  621.                 if (pNode)                   
  622.                     pNode = pNode->mpRight;
  623.             }
  624.         }
  625.         return true;

  627.     }

  629.     //中序遍历,并把遍历的结果放到栈中，用户销毁这棵树。
  630.     template <typename T>
  631.     bool AVLTree<T>::inorderTravel(Stack<TreeNode<T>*>& s)
  632.     {
  633.         TreeNode<T>* pNode = this->mpRoot->mpLeft;
  634.         if (pNode)
  635.         {
  636.             Stack<TreeNode<T>*> sTmp;
  637.             while (pNode || !sTmp.isEmpty())
  638.             {
  639.                 while (pNode)
  640.                 {
  641.                     sTmp.push(pNode);
  642.                     pNode = pNode->mpLeft;
  643.                 }
  644.                 pNode = sTmp.pop();
  645.                 if (pNode)
  646.                 {
  647.                     s.push(pNode);
  648.                     pNode = pNode->mpRight;
  649.                 }                       
  650.             }
  651.         }
  652.         return true;
  653.     }

  655.     //求一棵树的最大长度的路径。
  656.     template <typename T>
  657.     bool AVLTree<T>::getLongestPath(const TreeNode<T>* pRoot,Queue<TreeNode<T>*>& q)
  658.     {
  659.         if (!pRoot)    return false;
  660.         q.insert((TreeNode<T>*)(pRoot));
  661.         if ((SAFE_CALL(pRoot->mpLeft)->mHeigh) >= (SAFE_CALL(pRoot->mpRight)->mHeigh))
  662.             return getLongestPath(pRoot->mpLeft,q);
  663.         else
  664.             return getLongestPath(pRoot->mpRight,q);

  666.         return true;
  667.     }

  669.     //检查是否是AVL树。
  670.     template <typename T>
  671.     bool AVLTree<T>::checkIsAVLTree(void)
  672.     {
  673.             Stack<TreeNode<T>*> s;
  674.             this->inorderTravel(s);
  675.             TreeNode<T>* pNode = NULL;
  676.             while ((pNode= s.pop()) != NULL)   
  677.             {
  678.                 cout << "[" << pNode->mElement<<"]"                    \
  679.                     <<" Height:" << pNode->mHeigh                        \
  680.                     <<" Left:" << (SAFE_CALL(pNode->mpLeft)->mHeigh)    \
  681.                     <<" Rigth:"<< (SAFE_CALL(pNode->mpRight)->mHeigh)    \
  682.                     <<" bala:" << Balance(pNode) << endl;
  683.             }
  684.         return true;
  685.     }

  687.     #include <fstream>
  688.     using namespace std;
  689.     //把AVL树的信息丰收放到文件中
  690.     template <typename T>
  691.     void AVLTree<T>::saveAVLTreeToFile(const char* pFileName)
  692.     {
  693.         if (!pFileName) return;
  694.         FILE* pFile = fopen(pFileName,"w");
  695.         if (!pFile)
  696.         {
  697.             cout << "open file failed." << endl ;
  698.             return ;
  699.         }
  700.         char tmpBuf[512] = {0};
  701.         Stack<TreeNode<T>*> s;
  702.         this->inorderTravel(s);
  703.         sprintf(tmpBuf,"TreeSize: %d\r\n",s.size());
  704.         fwrite(tmpBuf,strlen(tmpBuf),1,pFile);

  706.         TreeNode<T>* pNode = NULL;
  707.         int iMaxHeigh = 0;
  708.         while ((pNode= s.pop()) != NULL)   
  709.         {
  710.             if (pNode->mHeigh > iMaxHeigh)
  711.             {
  712.                 iMaxHeigh = pNode->mHeigh;
  713.             }
  714.             sprintf(tmpBuf,"[%d]--Hegigh:%d--Left:%d--Right:%d--Bala:%d\r\n",
  715.                 pNode->mElement,
  716.                 pNode->mHeigh,
  717.                 (SAFE_CALL(pNode->mpLeft)->mHeigh),
  718.                 (SAFE_CALL(pNode->mpRight)->mHeigh),
  719.                 Balance(pNode));

  721.             fwrite(tmpBuf,strlen(tmpBuf),1,pFile);           
  722.         }
  723.         sprintf(tmpBuf,"iMaxHeigh: %d\r\n",iMaxHeigh);
  724.         fwrite(tmpBuf,strlen(tmpBuf),1,pFile);   
  725.         fclose(pFile);
  726.         pFile = NULL;
  727.     }   
  728. }
  729. #endif

/******************************测试函数*****************************************///

  1. #include <stdexcept>
  2. #include <typeinfo>
  3. #include <iostream>
  4. #include <fstream>
  5. using namespace std;
  6. #include "AVLTree.h"
  7. #include "Stack.h"
  8. #include "Queue.h"
  9. using namespace _AVL_Tree_;

  11. #include <time.h>

  13. #define ARRY_SIZE        1000
  14. int main(int argc,char** argv)
  15. {
  16.     AVLTree<int> tree;

  18. //    int arr[]    = {1,2,3};//RR
  19. //     int arr[]    = {3,2,1};//LL
  20. //    int arr[]    = {2,4,3};//RL
  21. //     int arr[]    = {4,2,3};//LR
  22. //     int arr[]    = {10,5,3,7,6,8,12,54,11};    //删除8后，还要再次平衡处理右子树
  23. //     int arr[]    = {100,50,30,70,60,80,120,540,110,51,75,112,85,78,71};    //删除 后，还要再次平衡处理左子树85,71,78,79
  24.     int arr[ARRY_SIZE] = {0};
  25.     srand((unsigned int)time(NULL));
  26.     for (int i = 0; i < ARRY_SIZE; i++)
  27.     {
  28.         arr[i] = (rand() % ARRY_SIZE) + 1;
  29.     }
  30.     size_t size = sizeof(arr) / sizeof(int);
  31.    
  32.      for (size_t i = 0; i < size; i++)
  33.      {
  34.          tree.insert(arr[i]);
  35.      }

  37.     cout << "Befor Inorder:";
  38.     tree.inorderTravel();
  39.     cout << "\nBefor Preorder:";
  40.     tree.prevorederTravel();

  42.     tree.saveAVLTreeToFile("AVLResult.txt");

  44.     cout << "\r\nAVLTree Result writes in file AVLResult.txt." << endl;
  45.     getchar();
  46.     return 0;
  47. }

 

///*****************************C++实现栈***************************************///

  1. //Stack.h
  2. //双链表栈数据结构C++模块的实现
  3. //理论知识参考《数据结构（C语言版）--严慰明》
  4. #ifndef _STACK_H_
  5. #define _STACK_H_
  6. #include <iostream>
  7. using namespace std;
  8. namespace _STACK_
  9. {
  10. //栈中的元素
  11. template <typename T>
  12. class StackNode
  13. {
  14. public:
  15.   StackNode()
  16.   {
  17.    this->mElement = 0;
  18.    this->mpNext = NULL;
  19.    this->mpPrev = NULL;
  20.   }
  21.  
  22.   ~StackNode()
  23.   {
  24.    this->mElement = 0;
  25.    this->mpNext = NULL;
  26.    this->mpPrev = NULL;
  27.   }
  28.  
  29.   T& getElement(void)
  30.   {
  31.    return mElement;
  32.   }
  33.  
  34.   //重载"<<"操作符，以便对栈节点输出，注意以friend重载“<<”操作符要加上"<>"
  35.   friend ostream& operator << <>(ostream& ost,StackNode<T>& src)
  36.   {
  37.    ost << src.mElement;
  38.    return ost;
  39.   }
  40.  
  41. //protected:
  42.   T mElement; //存放的数据
  43.   StackNode<T>* mpNext; //指向后继节点指针
  44.   StackNode<T>* mpPrev; //指向前驱节点指针
  45.   template <typename T>
  46.   friend class Stack;
  47. };

  49. template <typename T>
  50. class Stack
  51. {
  52. public:
  53.   Stack();
  54.   ~Stack();
  55.   bool push(const T& element);
  56.   T pop(void);
  57.   bool isEmpty(void);
  58.   bool clear(void);
  59.   int size();
  60.   friend ostream& operator<< <>(ostream& ost,Stack<T>& src);
  61. protected:
  62.   StackNode<T>* createNode(const T& element);
  63. protected:
  64.   StackNode<T>* mpHead;
  65.   StackNode<T>* mpTop;
  66. };

  68. template <typename T>
  69. Stack<T>::Stack()
  70. {
  71.   T i = T();
  72.   //创建一个带有头节点的双链栈，这个节点不存入任何数据
  73.   this->mpHead = this->createNode(i);
  74.   this->mpTop = this->mpHead;
  75. }

  77. template <typename T>
  78. Stack<T>::~Stack()
  79. {
  80.   this->clear();
  81.   delete this->mpHead;
  82.   this->mpHead = NULL;
  83.   this->mpTop = NULL;
  84. }

  86. template <typename T>
  87. StackNode<T>* Stack<T>::createNode(const T& element)
  88. {
  89.   StackNode<T>* pNode = new StackNode<T>;
  90.   if (pNode)
  91.   {
  92.    pNode->mElement = element;
  93.    pNode->mpNext = NULL;
  94.    pNode->mpPrev = NULL;
  95.   }
  96.   return pNode;
  97. }

  99. template <typename T>
  100. bool Stack<T>::push(const T& element)
  101. {
  102.   StackNode<T>* pNode = createNode(element);
  103.   if(this->mpHead->mpNext == NULL)
  104.   {
  105.    this->mpHead->mpNext = pNode;
  106.    pNode->mpPrev = this->mpHead;
  107.   }
  108.   else
  109.   {
  110.    this->mpTop->mpNext = pNode;
  111.    pNode->mpPrev = this->mpTop;
  112.   }
  113.   this->mpTop = pNode;
  114.   return true;
  115. }

  117. template <typename T>
  118. T Stack<T>::pop(void)
  119. {
  120.   if (this->mpTop != this->mpHead)
  121.   {
  122.    StackNode<T>* pNode = this->mpTop;
  123.    this->mpTop = this->mpTop->mpPrev;
  124.    T elem = pNode->mElement;
  125.    pNode ->mpNext = pNode->mpPrev = NULL;
  126.    delete pNode;
  127.    pNode = NULL;
  128.    return elem;
  129.   }
  130.   return (T)0;
  131. }

  133. template <typename T>
  134. bool Stack<T>::isEmpty(void)
  135. {
  136.   return (this->mpHead == this->mpTop);
  137. }

  139. template <typename T>
  140. bool Stack<T>::clear(void)
  141. {
  142.   StackNode<T>* pNode = this->mpTop;
  143.   while((pNode = this->mpTop) != this->mpHead)
  144.   {
  145.    this->mpTop =pNode->mpPrev;
  146.    pNode->mpNext = NULL;
  147.    pNode->mpPrev = NULL;
  148.    delete pNode;
  149.    pNode = NULL;
  150.   }
  151.   return true;
  152. }

  154. template <typename T>
  155. int Stack<T>::size()
  156. {
  157.   int iCount = 0;
  158.   StackNode<T>* pNode = this->mpTop;
  159.   while(pNode != this->mpHead)
  160.   {
  161.    iCount++;
  162.    pNode = pNode->mpPrev;
  163.   }
  164.   return iCount;
  165. }

  167. template <typename T>
  168. ostream& operator<< <>(ostream& ost,Stack<T>& src)
  169. {
  170.   StackNode<T>* pNode = src.mpTop;
  171.   while( src.mpHead)
  172.   {
  173.    ost << *pNode << " ";
  174.    pNode = pNode->mpPrev;
  175.   }
  176.   return ost;
  177. }
  178. }
  179. #endif

 

///***************************************C++实现队列*********************************

  1. //Queue.h
  2. //双链表队列数据结构C++模块的实现
  3. //理论知识参考《数据结构（C语言版）--严慰明》
  4. #ifndef _QUEUE_H_
  5. #define _QUEUE_H_

  7. namespace _QUEUE_
  8. {
  9.     //队列中的数据元素
  10.     template <typename T>
  11.     class QueueNode
  12.     {
  13.     public:
  14.         QueueNode()
  15.         {
  16.             this->mElement    = 0;
  17.             this->mpNext = this->mpPrev    = NULL;
  18.         }
  19.         T                mElement;
  20.         QueueNode<T>*    mpNext;
  21.         QueueNode<T>* mpPrev;
  22.     };

  24.     template <typename T>
  25.     class Queue
  26.     {
  27.     public:
  28.         Queue()
  29.         {
  30.             QueueNode<T> * pNode = new QueueNode<T>;
  31.             pNode->mElement = T(-1);
  32.             pNode->mpNext = pNode->mpPrev = NULL;
  33.             this->mpHead = this->mpTail = pNode;
  34.         }

  36.         ~Queue()
  37.         {
  38.             this->clear();
  39.             delete this->mpHead;
  40.             this->mpHead = this->mpTail = NULL;
  41.         }

  43.         bool insert(T element);
  44.         T    front();
  45.         T    back();
  46.         bool isEmpty(void);
  47.         bool clear(void);
  48.         int size();

  50.         friend ostream& operator<< <>(ostream& ostr,const Queue<T>& q);
  51.     private:
  52.         QueueNode<T>* mpHead;
  53.         QueueNode<T>* mpTail;
  54.     };

  56.     template <typename T>
  57.     bool Queue<T>::insert(T element)
  58.     {
  59.         QueueNode<T> * pNode = new QueueNode<T>;
  60.         if (pNode == NULL)    return false;
  61.         pNode->mElement    = element;

  63.         this->mpTail->mpNext = pNode;
  64.         pNode->mpPrev = this->mpTail;
  65.         this->mpTail = this->mpTail->mpNext;

  67.         return true;
  68.     }

  70.     template <typename T>
  71.     T    Queue<T>::front()
  72.     {
  73.         T element = T();
  74.         QueueNode<T>* pNode = NULL;
  75.         if (!this->isEmpty())
  76.         {
  77.             pNode = this->mpHead->mpNext;
  78.             element = pNode->mElement;
  79.             this->mpHead ->mpNext = pNode->mpNext;
  80.             if (pNode->mpNext)
  81.                 pNode->mpNext->mpPrev = this->mpHead;
  82.             if (pNode == this->mpTail)
  83.                 this->mpTail = this->mpHead;
  84.             delete pNode;
  85.         }
  86.         return element;
  87.     }

  89.     template <typename T>
  90.     T    Queue<T>::back()
  91.     {
  92.         T element = T();
  93.         QueueNode<T>* pNode = NULL;
  94.         if (!this->isEmpty())
  95.         {
  96.             pNode = this->mpTail;
  97.             element = pNode->mElement;
  98.             this->mpTail = this->mpTail->mpPrev;
  99.             this->mpTail->mpNext = NULL;
  100.             delete pNode;
  101.         }
  102.         return element;
  103.     }

  105.     template <typename T>
  106.     bool Queue<T>::isEmpty(void)
  107.     {
  108.         return (this->mpTail == this->mpHead);
  109.     }

  111.     template <typename T>
  112.     bool Queue<T>::clear(void)
  113.     {
  114.         while (!this->isEmpty())
  115.             this->back();
  116.         return true;
  117.     }

  119.     template <typename T>
  120.     int Queue<T>::size()
  121.     {
  122.         int iCount = 0;
  123.         if (!this->isEmpty())
  124.         {
  125.             QueueNode<T>* pNode = this->mpTail;
  126.             while (pNode != this->mpHead)
  127.             {
  128.                 iCount++;
  129.                 pNode = pNode->mpPrev;
  130.             }
  131.         }
  132.         return iCount;
  133.     }

  135.     template <typename T>
  136.     ostream& operator<< <>(ostream& ostr,const Queue<T>& q)
  137.     {
  138.         QueueNode<T>* pNode = q.mpHead->mpNext;
  139.         while (pNode != NULL)
  140.         {
  141.             ostr << pNode->mElement << ",";
  142.             pNode = pNode->mpNext;
  143.         }
  144.         return ostr;
  145.     }
  146. }
  147. #endif

 

 

gwbin198808
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于C++ AVL树的航空客运订票系统【100012693】
06-12
在C++中，AVL树的实现需要定义节点结构，包含键值、高度、指向左右子节点的指针，以及用于调整平衡的旋转操作（左旋和右旋）。 在该航空订票系统中，AVL树被用来存储航班记录。每个航班记录包含航班号、起飞和降落...
c++写的平衡树数据结构
03-24
在这个C++实现中，我们可能看到的是AVL树或者红黑树，因为它们是最常见的平衡树类型，且都支持高效的插入和删除操作。AVL树以其严格的平衡条件（所有节点的左右子树高度差不超过1）而闻名，而红黑树则相对宽松，允许...
二叉查找树+AVL树.zip
03-11
在"二叉查找树.sln"文件中，可能包含了使用某种编程语言（如C#或C++）实现的二叉查找树的项目解决方案。这个解决方案可能包括了源代码文件、编译配置和测试用例等，用于演示二叉查找树的基本操作，如插入、查找和...
二叉树-基于C++实现的平衡二叉树.zip
04-26
接着，我们需要实现基本操作如插入、删除和查找，以及在这些操作后进行的平衡调整（如AVL树的旋转或红黑树的颜色调整）。在C++中，我们可以使用类来封装这些操作，使代码更加模块化和易于理解。 在实际应用中，平衡...
高一凡的C++数据结构实现源码
12-05
C++是一种强大的、通用的编程语言，尤其适合实现数据结构，因为它支持面向对象编程，可以创建复杂的类层次结构和封装，使得数据结构的实现更加模块化和易于理解。 在《面向对象的C++数据结构算法实现与解析》这个...
Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印 方便用于小论文写作，方便用于毕业设计
07-20
Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可
K-means聚类算法MATLAB代码.doc
07-20
kmeans聚类算法matlab代码
计算机科学与技术_基于Android的新闻管理系统的设计与实现.docx
07-20
计算机科学与技术_基于Android的新闻管理系统的设计与实现
半自动光纤接头组装机_包括零件图_机械3D图可修改打包下载.zip
07-20
半自动光纤接头组装机_包括零件图_机械3D图可修改打包下载.zip
[课设项目]Java-SSM框架开发校园资讯推荐系统+jsp+MySQL+前后端分离毕业论文和源码.zip
07-20
本项目是一个基于Java-SSM框架开发的校园资讯推荐系统，旨在为学生提供个性化的资讯推荐服务。项目采用前后端分离的设计模式，前端使用JSP进行页面展示，后端则通过SSM框架实现数据处理和业务逻辑。数据库方面，项目采用了MySQL作为存储数据的工具，确保了数据的稳定性和安全性。 项目资源包括完整的项目源码、数据库脚本以及详细的开发说明，同时还提供了相关论文作为参考。无论是正在进行毕业设计的学生还是需要进行项目实战练习的Java学习者，都可以通过本项目获得宝贵的实践经验。 值得一提的是，项目已经过严格的调试过程，确保可以在JDK、IDEA和Tomcat的开发环境下正常运行。对于有一定Java基础的学习者来说，还可以在项目现有代码的基础上进行拓展，实现更多功能，从而进一步提升自己的编程能力。请放心下载使用，本项目将是您毕业设计或课程设计的得力助手。
基于Springboot的物流管理系统论文
07-20
传统信息管理主要依赖管理人员的手工登记与管理。然而，近年来信息技术的快速发展促使许多陈旧的信息管理模式进行了更新与迭代。货运信息因其管理内容复杂、数量庞大，手工处理方式已无法满足广大用户的需求，于是兴顺物流管理系统应运而生。 兴顺物流管理系统分为管理员和用户两个角色。管理员负责管理用户的基本信息、物流资讯及货运信息，并能与用户进行交流等。用户则可以查看货运信息、物流资讯以及管理员的回复信息等。 该系统采用了WEB应用程序开发中流行的小程序结构模式，并使用占用空间小但功能完备的MySQL数据库进行数据存储。系统开发过程中运用了JSP技术。兴顺物流管理系统能够解决传统手工操作中的诸多难题，如数据查询耗时长、数据管理步骤繁琐等。总体而言，该系统性能稳定、功能全面，投入运行后具有较高的性价比。
复盘方法论操作手册-整理
07-20
复盘方法论操作手册
数据结构与算法基础课程 C语言C++程序语言设计教程 4_1串 共18页.pptx
07-20
【课程大纲】 1_0 课程简介 共7页.pptx 2_1绪论 共32页.pptx 2_2线性表-顺序表 共12页.pptx 2_3线性表-链表 共43页.pptx 3_1栈和队列 共29页.pptx 3_2递归和非递归 共22页.pptx 4_1串 共18页.pptx 5_1 数组 共19页.pptx 6_1二叉树 共19页.pptx 6_2森林和哈夫曼树 共15页.pptx 7_1 图（存储、遍历、连通） 共49页.pptx 7_2图（拓扑排序、关键路径、最短路径） 共52页.pptx 8_1集合与查找（静态查找、哈希、二叉排序树、平衡二叉树） 共28页.pptx 8_2集合与查找（B-树） 共12页.pptx 9内排序 共25页.pptx
12CN10N-VB TO220一种N-Channel沟道TO220封装MOS管
07-20
12CN10N-VB TO220一种N-Channel沟道TO220封装MOS管
11NM60ND-VB TO251一种N-Channel沟道TO251封装MOS管
07-20
11NM60ND-VB TO251；Package：TO251；Configuration：Single-N-Channel；VDS：650V；VGS：30（±V）；Vth：3.5V；RDS(ON)=370mΩ@VGS=10V；ID：11A；Technology：SJ_Multi-EPI；
Python 小程序示例代码.doc
最新发布
07-20
python小程序代码
数据结构与算法基础课程 C语言C++程序语言设计教程 9内排序 共25页.pptx
07-20
【课程大纲】 1_0 课程简介 共7页.pptx 2_1绪论 共32页.pptx 2_2线性表-顺序表 共12页.pptx 2_3线性表-链表 共43页.pptx 3_1栈和队列 共29页.pptx 3_2递归和非递归 共22页.pptx 4_1串 共18页.pptx 5_1 数组 共19页.pptx 6_1二叉树 共19页.pptx 6_2森林和哈夫曼树 共15页.pptx 7_1 图（存储、遍历、连通） 共49页.pptx 7_2图（拓扑排序、关键路径、最短路径） 共52页.pptx 8_1集合与查找（静态查找、哈希、二叉排序树、平衡二叉树） 共28页.pptx 8_2集合与查找（B-树） 共12页.pptx 9内排序 共25页.pptx
希赛信息系统项目管理师第四版精排版
07-20
6_希赛信息系统项目管理师第四版精排版
编程不良人b站RabbitMQ笔记MD下载，自费购买，侵删致歉
07-20
编程不良人b站RabbitMQ笔记MD下载，自费购买，侵删致歉
avl树c++
05-24
下面是一个简单的AVL树的C++实现： ```c++ #include using namespace std; // AVL树节点 struct Node { int key; int height; Node *left; Node *right; Node(int k) : key(k), height(1), left(NULL), ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值