AVL树（C++模块实现）

2023年5月19日 376次阅读 来源: 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

 

 

    原文作者：AVL树
    原文地址: https://blog.csdn.net/gwbin198808/article/details/8700253
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞