平衡二叉树是一个重要的数据结构，它有很均衡的插入、删除以及查询性能（时间复杂度都是O(logn)）。Linux2.4以前的内核中，虚拟内存管理中用的容器就是AVL Tree，之后的版本都改成了RBTree即红黑树。AVL Tree对平衡的要求是比较严格的，它要求左右子数之间的长度差不能大于1，也正由于它的严格导致了AVL Tree的统计性能没有RBTree好。AVL Tree在插入或者删除节点时候出现不平衡情况，根据具体情况进行一次或者多次单旋或者双旋就可以使整棵树达到平衡。具体的旋转规则看这里，删除节点的算法看这里。下面是我根据AVL树的规则用C++实现的代码：

  1 #ifndef        __AVLTREE_H__
  2 #define        __AVLTREE_H__
  3 
  4 #include <stdlib.h>
  5 #include <iostream>
  6 
  7 struct AVLNode
  8 {
  9     int nData;
 10     AVLNode* pLeft;
 11     AVLNode* pRight;
 12     AVLNode* pParent;
 13     int nHeight;
 14 };
 15 
 16 class AVLTree
 17 {
 18 public:
 19     AVLTree() : pRoot(NULL), nNodeCount(0){}
 20     ~AVLTree(){ DeleteTree(&pRoot); }
 21 public:
 22     int Insert(int nData);
 23     int Delete(int nData);
 24     int Find(int nData) const;
 25     int GetNodeCount() const;
 26     void Display() const;
 27 
 28 private:
 29     int Max(int a, int b) const;
 30     int Height(const AVLNode* pNode) const;
 31     AVLNode* CreateNode(int nData);
 32     AVLNode* DeleteNode(int nData, AVLNode* pNode);
 33     AVLNode* BalanceAdjust(AVLNode* pNode);
 34     AVLNode* RotateLeft(AVLNode* pNode);
 35     AVLNode* RotateRight(AVLNode* pNode);
 36     AVLNode* RotateLeftRight(AVLNode* pNode);
 37     AVLNode* RotateRightLeft(AVLNode* pNode);
 38     void DeleteTree(AVLNode** ppRoot);
 39     void PrintTree(AVLNode* pNode) const;
 40 
 41     AVLTree(const AVLTree&) {}
 42     AVLTree& operator=(const AVLTree&) {}
 43 
 44 private:
 45     AVLNode* pRoot;
 46     int nNodeCount;
 47 };
 48 
 49 int AVLTree::Max(int a, int b) const
 50 {
 51     return (a > b ? a : b);
 52 }
 53 
 54 int AVLTree::Height(const AVLNode* pNode) const
 55 {
 56     if (NULL == pNode)
 57         return -1;
 58 
 59     return pNode->nHeight;
 60 }
 61 
 62 int AVLTree::Insert(int nData)
 63 {
 64     if(pRoot == NULL)
 65     {
 66         pRoot = CreateNode(nData);
 67 
 68         return nNodeCount;
 69     }
 70 
 71     AVLNode* pInsertNode = pRoot;
 72 
 73     while(pInsertNode != NULL)
 74     {
 75         if(nData < pInsertNode->nData)
 76         {
 77             if(pInsertNode->pLeft == NULL)
 78             {
 79                 pInsertNode->pLeft = CreateNode(nData);
 80                 pInsertNode->pLeft->pParent = pInsertNode;
 81 
 82                 pRoot = BalanceAdjust(pInsertNode->pLeft);
 83                 break;
 84             }
 85 
 86             pInsertNode = pInsertNode->pLeft;
 87         }
 88         else if(nData > pInsertNode->nData)
 89         {
 90             if(pInsertNode->pRight == NULL)
 91             {
 92                 pInsertNode->pRight = CreateNode(nData);
 93                 pInsertNode->pRight->pParent = pInsertNode;
 94 
 95                 pRoot = BalanceAdjust(pInsertNode->pRight);
 96                 break;
 97             }
 98 
 99             pInsertNode = pInsertNode->pRight;
100         }
101         else
102         {
103             return nNodeCount;
104         }
105     }
106 
107     return nNodeCount;
108 }
109 
110 int AVLTree::Delete(int nData)
111 {
112     //std::cout << "Delete nData = " << nData << std::endl;
113     //std::cout << "pNode->nData = " << pNode->nData << std::endl;
114     //std::cout << "pPNode->nData = " << pPNode->nData << std::endl;
115 
116     AVLNode* pCurNode = pRoot;
117 
118     while(pCurNode != NULL)
119     {
120         if(nData > pCurNode->nData)
121         {
122             pCurNode = pCurNode->pRight;
123         }
124         else if(nData < pCurNode->nData)
125         {
126             pCurNode = pCurNode->pLeft;
127         }
128         else
129         {
130             pRoot = DeleteNode(nData, pCurNode);
131             break;
132         }
133     }
134 
135 
136     if(pCurNode == NULL)
137         std::cout << "没有找到元素 nData = " << nData << std::endl;
138     //int x;
139     //std::cin >> x;
140 
141     return nNodeCount;//没有找到要删除的元素    
142 }
143 
144 AVLNode* AVLTree::DeleteNode(int nData, AVLNode* pNode)
145 {
146     nNodeCount--;
147 
148     if(pNode->pLeft && pNode->pRight)//删除节点有左右子树
149     {
150         AVLNode* pLMaxNode = pNode->pLeft;//删除节点左子树中最大的节点
151         AVLNode* pLMaxPNode = pNode;//删除节点左子树中最大节点的父节点
152 
153         //将删除节点左孩子的最大节点替换删除节点,然后删除该节点
154         if(pLMaxNode->pRight == NULL)
155         {
156             pNode->nData = pLMaxNode->nData;
157             pNode->pLeft = pLMaxNode->pLeft;
158 
159             if(pLMaxNode->pLeft != NULL)
160                 pLMaxNode->pLeft->pParent = pNode;
161         }
162         else
163         {
164             while(pLMaxNode->pRight)
165             {
166                 pLMaxPNode = pLMaxNode;
167                 pLMaxNode = pLMaxNode->pRight;
168             }
169             pNode->nData = pLMaxNode->nData;
170 
171             if(pLMaxNode == pLMaxPNode->pRight)//将替换后的删除节点删除
172                 pLMaxPNode->pRight = pLMaxNode->pLeft;
173             else if(pLMaxNode == pLMaxPNode->pLeft)
174                 pLMaxPNode->pLeft = NULL;
175         }
176         
177         delete pLMaxNode;
178 
179         return BalanceAdjust(pLMaxPNode);
180     }
181     else if(pNode->pLeft)//删除节点只有左子树
182     {
183         AVLNode* pLeft = pNode->pLeft;
184 
185         pNode->nData = pLeft->nData;
186 
187         pNode->pLeft = pLeft->pLeft;
188         if (pLeft->pLeft != NULL)
189             pLeft->pLeft->pParent = pNode;
190 
191         pNode->pRight = pLeft->pRight;
192         if (pLeft->pRight != NULL)
193             pLeft->pRight->pParent = pNode;
194         
195         delete pLeft;
196 
197         return BalanceAdjust(pNode);
198     }
199     else if(pNode->pRight)//删除节点只有右子树
200     {
201         AVLNode* pRight = pNode->pRight;
202 
203         pNode->nData = pRight->nData;
204 
205         pNode->pLeft = pRight->pLeft;
206         if (pRight->pLeft != NULL)
207             pRight->pLeft->pParent = pNode;
208 
209         pNode->pRight = pRight->pRight;
210         if (pRight->pRight != NULL)
211             pRight->pRight->pParent = pNode;
212         
213         delete pRight;
214 
215         return BalanceAdjust(pNode);
216     }
217     else//删除节点没有子树
218     {
219         AVLNode* pPNode = pNode->pParent;
220 
221         if(pPNode->pLeft == pNode)
222             pPNode->pLeft = NULL;
223         else if(pPNode->pRight == pNode)
224             pPNode->pRight = NULL;
225 
226         delete pNode;
227 
228         return BalanceAdjust(pPNode);
229     }
230 }
231 
232 AVLNode* AVLTree::BalanceAdjust(AVLNode* pNode)
233 {
234     AVLNode* pRoot;
235     AVLNode* pPNode;
236     
237     while(pNode != NULL)//删除节点的子节点进行平衡
238     {
239         pPNode = pNode->pParent;
240 
241         bool bIsLeft = false;
242         if(pPNode != NULL && pNode == pPNode->pLeft)
243             bIsLeft = true;
244 
245         pNode->nHeight = Max(Height(pNode->pLeft), Height(pNode->pRight)) + 1;
246 
247         if (Height(pNode->pLeft) - Height(pNode->pRight) == 2)    // AVL树不平衡  执行LL型或者LR型旋转
248         {
249             if (Height(pNode->pLeft->pLeft) - Height(pNode->pLeft->pRight) == -1)
250                 pNode = RotateLeftRight(pNode);
251             else 
252                 pNode = RotateLeft(pNode);
253 
254             if(pPNode != NULL && bIsLeft)
255                 pPNode->pLeft = pNode;
256             else if(pPNode != NULL)
257                 pPNode->pRight = pNode;
258         }
259         else if(Height(pNode->pLeft) - Height(pNode->pRight) == -2)    // AVL树不平衡  执行RR型或者RL型旋转
260         {
261             if (Height(pNode->pRight->pLeft) - Height(pNode->pRight->pRight) == 1)
262                 pNode = RotateRightLeft(pNode);
263             else
264                 pNode = RotateRight(pNode);
265 
266             if (pPNode != NULL && bIsLeft)
267                 pPNode->pLeft = pNode;
268             else if(pPNode != NULL)
269                 pPNode->pRight = pNode;
270         }
271 
272         pRoot = pNode;
273         pNode = pPNode;
274     }
275 
276     return pRoot;
277 }
278 
279 AVLNode* AVLTree::CreateNode(int nData)
280 {
281     nNodeCount++;
282 
283     AVLNode* pNewNode = new AVLNode();
284     pNewNode->nData = nData;
285     pNewNode->nHeight = 0;
286     pNewNode->pLeft = pNewNode->pRight = NULL;
287 
288     return pNewNode;
289 }
290 
291 int AVLTree::Find(int nData) const
292 {
293     AVLNode* pFindNode = pRoot;
294     while(pFindNode)
295     {
296         if(nData < pFindNode->nData)
297             pFindNode = pFindNode->pLeft;
298         else if(nData > pFindNode->nData)
299             pFindNode = pFindNode->pRight;
300         else
301             return pFindNode->nData;
302     }
303     
304     return -1;
305 }
306 
307 AVLNode* AVLTree::RotateLeft(AVLNode* pNode)//左单
308 {
309     AVLNode* pLeftChild;
310 
311     pLeftChild = pNode->pLeft;
312     pNode->pLeft = pLeftChild->pRight;
313     pLeftChild->pRight = pNode;
314 
315     pLeftChild->pParent = pNode->pParent;
316     pNode->pParent = pLeftChild;
317 
318     if(pNode->pLeft)
319         pNode->pLeft->pParent = pNode;
320 
321     // 结点的位置改变,节点高度要重新计算
322     pNode->nHeight = Max(Height(pNode->pLeft), Height(pNode->pRight)) + 1;
323     pLeftChild->nHeight = Max(Height(pLeftChild->pLeft), pNode->nHeight) + 1;
324 
325     return pLeftChild;
326 }
327 
328 AVLNode* AVLTree::RotateRight(AVLNode* pNode)//右单
329 {
330     AVLNode* pRightChild;
331 
332     pRightChild = pNode->pRight;
333     pNode->pRight = pRightChild->pLeft;
334     pRightChild->pLeft = pNode;
335 
336     pRightChild->pParent = pNode->pParent;
337     pNode->pParent = pRightChild;
338 
339     if(pNode->pRight)
340         pNode->pRight->pParent = pNode;
341 
342     // 结点的位置改变,节点高度要重新计算
343     pNode->nHeight = Max(Height(pNode->pLeft), Height(pNode->pRight)) + 1;
344     pRightChild->nHeight = Max(Height(pRightChild->pRight), pNode->nHeight) + 1;
345 
346     return pRightChild;
347 }
348 
349 AVLNode* AVLTree::RotateLeftRight(AVLNode* pNode)//左双
350 {
351     pNode->pLeft = RotateRight(pNode->pLeft);
352 
353     return RotateLeft(pNode);
354 }
355 
356 AVLNode* AVLTree::RotateRightLeft(AVLNode* pNode)//右双
357 {
358     pNode->pRight = RotateLeft(pNode->pRight);
359 
360     return RotateRight(pNode);
361 }
362 
363 // 后序遍历树以删除树
364 void AVLTree::DeleteTree(AVLNode** ppRoot)
365 {
366     if (NULL == ppRoot || NULL == *ppRoot)
367         return;
368 
369     DeleteTree(&((*ppRoot)->pLeft));
370     DeleteTree(&((*ppRoot)->pRight));
371     delete *ppRoot;
372     *ppRoot = NULL;
373 }
374 
375 int AVLTree::GetNodeCount() const
376 {
377     return nNodeCount;
378 }
379 
380 void AVLTree::Display() const
381 {
382      PrintTree(this->pRoot);
383 }
384 
385 void AVLTree::PrintTree(AVLNode* pNode) const
386 {
387     if (NULL == pRoot)
388         return;
389 
390     if (NULL == pNode)
391     {
392         return;
393     }
394 
395     static int n = 0;
396     
397     if(pNode == pRoot)
398     {
399         std::cout << "[" << ++n << "]nData = " << pNode->nData << ",nParentData= 0 ,";
400 
401         if(pNode->pLeft)
402             std::cout << "nLeftData= " << pNode->pLeft->nData << " ,";
403         if(pNode->pRight)
404             std::cout << "nRightData= " << pNode->pRight->nData << " ,";
405 
406         std::cout << "nHeight = " << pNode->nHeight << std::endl;
407     }
408     else
409     {
410         std::cout << "[" << ++n << "]nData = " << pNode->nData << ",nParentData= " << pNode->pParent->nData << " ,";
411 
412         if(pNode->pLeft)
413             std::cout << "nLeftData= " << pNode->pLeft->nData << " ,";
414         if(pNode->pRight)
415             std::cout << "nRightData= " << pNode->pRight->nData << " ,";
416 
417         std::cout << "nHeight = " << pNode->nHeight << std::endl;
418     }
419     PrintTree(pNode->pLeft);
420     PrintTree(pNode->pRight);
421 }
422 #endif        //__AVLTREE_H__

　　将上面的文件复制保存成文件AVLTree.h。然后将下面的复制到Test.cpp文件中。Test.cpp文件是简单的测试案例。

 1 #include "AVLTree.h"
 2 #include <iostream>
 3 #include <exception>
 4 
 5 int main()
 6 {
 7     try
 8     {
 9         AVLTree avl;
10         for(int i = 1; i < 10; i++)
11         {
12             avl.Insert(i);
13         }
14         
15         avl.Delete(4);
16         avl.Display();
17     }
18     catch (std::exception& e)
19     {
20         std::cout << e.what() << std::endl;
21     }
22 }

　　输入g++ -o Test Test.cpp然后回车就可以编译运行了。运行结果如下：

 1 [kiven@localhost Test]$ g++ -o Test Test.cpp
 2 [kiven@localhost Test]$ ./Test
 3 [1]nData = 3,nParentData= 0 ,nLeftData= 2 ,nRightData= 6 ,nHeight = 3
 4 [2]nData = 2,nParentData= 3 ,nLeftData= 1 ,nHeight = 1
 5 [3]nData = 1,nParentData= 2 ,nHeight = 0
 6 [4]nData = 6,nParentData= 3 ,nLeftData= 5 ,nRightData= 8 ,nHeight = 2
 7 [5]nData = 5,nParentData= 6 ,nHeight = 0
 8 [6]nData = 8,nParentData= 6 ,nLeftData= 7 ,nRightData= 9 ,nHeight = 1
 9 [7]nData = 7,nParentData= 8 ,nHeight = 0
10 [8]nData = 9,nParentData= 8 ,nHeight = 0
11 [kiven@localhost Test]$

　　我上面实现的版本也只是为了研究AVL树的属性而做的实验版本，节点中的数据也直接使用了整形，而在实际使用时需要实现模板的版本，或者用万能的指针。但是指针的方式显然没有模板好。我自己也实现了一个模板的版本，也是比较粗糙的，代码如下：

  1 #ifndef        __AVLTREE_H__
  2 #define        __AVLTREE_H__
  3 
  4 #include <iostream>
  5 
  6 template <typename T>
  7 class AVLNode
  8 {
  9 public:
 10     T data;
 11     AVLNode<T>* pLeft;
 12     AVLNode<T>* pRight;
 13     AVLNode<T>* pParent;
 14     int nHeight;
 15 };
 16 
 17 template <typename T>
 18 class AVLTree
 19 {
 20 public:
 21     AVLTree() : pRoot(NULL), nNodeCount(0){}
 22     virtual ~AVLTree(){ DeleteTree(&pRoot); }
 23 public:
 24     virtual AVLTree<T>& Insert(T data);
 25     virtual AVLTree<T>& Delete(T data);
 26     virtual int Find(T data) const;
 27     virtual int GetNodeCount() const;
 28     virtual void Display() const;
 29 
 30 private:
 31     int Max(int a, int b) const;
 32     int Height(const AVLNode<T>* pNode) const;
 33     AVLNode<T>* CreateNode(T data);
 34     AVLNode<T>* DeleteNode(T data, AVLNode<T>* pNode);
 35     AVLNode<T>* BalanceAdjust(AVLNode<T>* pNode);
 36     AVLNode<T>* RotateLeft(AVLNode<T>* pNode);
 37     AVLNode<T>* RotateRight(AVLNode<T>* pNode);
 38     AVLNode<T>* RotateLeftRight(AVLNode<T>* pNode);
 39     AVLNode<T>* RotateRightLeft(AVLNode<T>* pNode);
 40     void DeleteTree(AVLNode<T>** ppRoot);
 41     void PrintTree(AVLNode<T>* pNode) const;
 42 
 43     AVLTree(const AVLTree<T>&) {}
 44     AVLTree<T>& operator=(const AVLTree<T>&) {}
 45 
 46 private:
 47     AVLNode<T>* pRoot;
 48     int nNodeCount;
 49 };
 50 
 51 template <typename T>
 52 int AVLTree<T>::Max(int a, int b) const
 53 {
 54     return (a > b ? a : b);
 55 }
 56 
 57 template <typename T>
 58 int AVLTree<T>::Height(const AVLNode<T>* pNode) const
 59 {
 60     if (NULL == pNode)
 61         return -1;
 62 
 63     return pNode->nHeight;
 64 }
 65 
 66 template <typename T>
 67 AVLTree<T>& AVLTree<T>::Insert(T data)
 68 {
 69     if(pRoot == NULL)
 70     {
 71         pRoot = CreateNode(data);
 72 
 73         return *this;
 74     }
 75 
 76     AVLNode<T>* pInsertNode = pRoot;
 77 
 78     while(pInsertNode != NULL)
 79     {
 80         if(data < pInsertNode->data)
 81         {
 82             if(pInsertNode->pLeft == NULL)
 83             {
 84                 pInsertNode->pLeft = CreateNode(data);
 85                 pInsertNode->pLeft->pParent = pInsertNode;
 86 
 87                 pRoot = BalanceAdjust(pInsertNode->pLeft);
 88                 break;
 89             }
 90 
 91             pInsertNode = pInsertNode->pLeft;
 92         }
 93         else if(data > pInsertNode->data)
 94         {
 95             if(pInsertNode->pRight == NULL)
 96             {
 97                 pInsertNode->pRight = CreateNode(data);
 98                 pInsertNode->pRight->pParent = pInsertNode;
 99 
100                 pRoot = BalanceAdjust(pInsertNode->pRight);
101                 break;
102             }
103 
104             pInsertNode = pInsertNode->pRight;
105         }
106         else
107         {
108             return *this;
109         }
110     }
111 
112     return *this;
113 }
114 
115 template <typename T>
116 AVLTree<T>& AVLTree<T>::Delete(T data)
117 {
118     //std::cout << "Delete nData = " << nData << std::endl;
119     //std::cout << "pNode->nData = " << pNode->nData << std::endl;
120     //std::cout << "pPNode->nData = " << pPNode->nData << std::endl;
121 
122     AVLNode<T>* pCurNode = pRoot;
123 
124     while(pCurNode != NULL)
125     {
126         if(data > pCurNode->data)
127         {
128             pCurNode = pCurNode->pRight;
129         }
130         else if(data < pCurNode->data)
131         {
132             pCurNode = pCurNode->pLeft;
133         }
134         else
135         {
136             pRoot = DeleteNode(data, pCurNode);
137             break;
138         }
139     }
140 
141 
142     if(pCurNode == NULL)
143         std::cout << "没有找到元素 nData = " << data << std::endl;
144     //int x;
145     //std::cin >> x;
146 
147     return *this;//没有找到要删除的元素    
148 }
149 
150 template <typename T>
151 AVLNode<T>* AVLTree<T>::DeleteNode(T data, AVLNode<T>* pNode)
152 {
153     nNodeCount--;
154 
155     if(pNode->pLeft && pNode->pRight)//删除节点有左右子树
156     {
157         AVLNode<T>* pLMaxNode = pNode->pLeft;//删除节点左子树中最大的节点
158         AVLNode<T>* pLMaxPNode = pNode;//删除节点左子树中最大节点的父节点
159 
160         //将删除节点左孩子的最大节点替换删除节点,然后删除该节点
161         if(pLMaxNode->pRight == NULL)
162         {
163             pNode->data = pLMaxNode->data;
164             pNode->pLeft = pLMaxNode->pLeft;
165 
166             if(pLMaxNode->pLeft != NULL)
167                 pLMaxNode->pLeft->pParent = pNode;
168         }
169         else
170         {
171             while(pLMaxNode->pRight)
172             {
173                 pLMaxPNode = pLMaxNode;
174                 pLMaxNode = pLMaxNode->pRight;
175             }
176             pNode->data = pLMaxNode->data;
177 
178             if(pLMaxNode == pLMaxPNode->pRight)//将替换后的删除节点删除
179                 pLMaxPNode->pRight = pLMaxNode->pLeft;
180             else if(pLMaxNode == pLMaxPNode->pLeft)
181                 pLMaxPNode->pLeft = NULL;
182         }
183         
184         delete pLMaxNode;
185 
186         return BalanceAdjust(pLMaxPNode);
187     }
188     else if(pNode->pLeft)//删除节点只有左子树
189     {
190         AVLNode<T>* pLeft = pNode->pLeft;
191 
192         pNode->data = pLeft->data;
193 
194         pNode->pLeft = pLeft->pLeft;
195         if (pLeft->pLeft != NULL)
196             pLeft->pLeft->pParent = pNode;
197 
198         pNode->pRight = pLeft->pRight;
199         if (pLeft->pRight != NULL)
200             pLeft->pRight->pParent = pNode;
201         
202         delete pLeft;
203 
204         return BalanceAdjust(pNode);
205     }
206     else if(pNode->pRight)//删除节点只有右子树
207     {
208         AVLNode<T>* pRight = pNode->pRight;
209 
210         pNode->data = pRight->data;
211 
212         pNode->pLeft = pRight->pLeft;
213         if (pRight->pLeft != NULL)
214             pRight->pLeft->pParent = pNode;
215 
216         pNode->pRight = pRight->pRight;
217         if (pRight->pRight != NULL)
218             pRight->pRight->pParent = pNode;
219         
220         delete pRight;
221 
222         return BalanceAdjust(pNode);
223     }
224     else//删除节点没有子树
225     {
226         AVLNode<T>* pPNode = pNode->pParent;
227 
228         if(pPNode->pLeft == pNode)
229             pPNode->pLeft = NULL;
230         else if(pPNode->pRight == pNode)
231             pPNode->pRight = NULL;
232 
233         delete pNode;
234 
235         return BalanceAdjust(pPNode);
236     }
237 }
238 
239 template <typename T>
240 AVLNode<T>* AVLTree<T>::BalanceAdjust(AVLNode<T>* pNode)
241 {
242     AVLNode<T>* pRoot;
243     AVLNode<T>* pPNode;
244     
245     while(pNode != NULL)//删除节点的子节点进行平衡
246     {
247         pPNode = pNode->pParent;
248 
249         bool bIsLeft = false;
250         if(pPNode != NULL && pNode == pPNode->pLeft)
251             bIsLeft = true;
252 
253         pNode->nHeight = Max(Height(pNode->pLeft), Height(pNode->pRight)) + 1;
254 
255         if (Height(pNode->pLeft) - Height(pNode->pRight) == 2)    // AVL树不平衡  执行LL型或者LR型旋转
256         {
257             if (Height(pNode->pLeft->pLeft) - Height(pNode->pLeft->pRight) == -1)
258                 pNode = RotateLeftRight(pNode);
259             else 
260                 pNode = RotateLeft(pNode);
261 
262             if(pPNode != NULL && bIsLeft)
263                 pPNode->pLeft = pNode;
264             else if(pPNode != NULL)
265                 pPNode->pRight = pNode;
266         }
267         else if(Height(pNode->pLeft) - Height(pNode->pRight) == -2)    // AVL树不平衡  执行RR型或者RL型旋转
268         {
269             if (Height(pNode->pRight->pLeft) - Height(pNode->pRight->pRight) == 1)
270                 pNode = RotateRightLeft(pNode);
271             else
272                 pNode = RotateRight(pNode);
273 
274             if (pPNode != NULL && bIsLeft)
275                 pPNode->pLeft = pNode;
276             else if(pPNode != NULL)
277                 pPNode->pRight = pNode;
278         }
279 
280         pRoot = pNode;
281         pNode = pPNode;
282     }
283 
284     return pRoot;
285 }
286 
287 template <typename T>
288 AVLNode<T>* AVLTree<T>::CreateNode(T data)
289 {
290     nNodeCount++;
291 
292     AVLNode<T>* pNewNode = new AVLNode<T>();
293     pNewNode->data = data;
294     pNewNode->nHeight = 0;
295     pNewNode->pLeft = pNewNode->pRight = NULL;
296 
297     return pNewNode;
298 }
299 
300 template <typename T>
301 int AVLTree<T>::Find(T data) const
302 {
303     AVLNode<T>* pFindNode = pRoot;
304     while(pFindNode)
305     {
306         if(data < pFindNode->data)
307             pFindNode = pFindNode->pLeft;
308         else if(data > pFindNode->data)
309             pFindNode = pFindNode->pRight;
310         else
311             return 1;//pFindNode->data;
312     }
313     
314     return 0;
315 }
316 
317 template <typename T>
318 AVLNode<T>* AVLTree<T>::RotateLeft(AVLNode<T>* pNode)//左单
319 {
320     AVLNode<T>* pLeftChild;
321 
322     pLeftChild = pNode->pLeft;
323     pNode->pLeft = pLeftChild->pRight;
324     pLeftChild->pRight = pNode;
325 
326     pLeftChild->pParent = pNode->pParent;
327     pNode->pParent = pLeftChild;
328 
329     if(pNode->pLeft)
330         pNode->pLeft->pParent = pNode;
331 
332     // 结点的位置改变,节点高度要重新计算
333     pNode->nHeight = Max(Height(pNode->pLeft), Height(pNode->pRight)) + 1;
334     pLeftChild->nHeight = Max(Height(pLeftChild->pLeft), pNode->nHeight) + 1;
335 
336     return pLeftChild;
337 }
338 
339 template <typename T>
340 AVLNode<T>* AVLTree<T>::RotateRight(AVLNode<T>* pNode)//右单
341 {
342     AVLNode<T>* pRightChild;
343 
344     pRightChild = pNode->pRight;
345     pNode->pRight = pRightChild->pLeft;
346     pRightChild->pLeft = pNode;
347 
348     pRightChild->pParent = pNode->pParent;
349     pNode->pParent = pRightChild;
350 
351     if(pNode->pRight)
352         pNode->pRight->pParent = pNode;
353 
354     // 结点的位置改变,节点高度要重新计算
355     pNode->nHeight = Max(Height(pNode->pLeft), Height(pNode->pRight)) + 1;
356     pRightChild->nHeight = Max(Height(pRightChild->pRight), pNode->nHeight) + 1;
357 
358     return pRightChild;
359 }
360 
361 template <typename T>
362 AVLNode<T>* AVLTree<T>::RotateLeftRight(AVLNode<T>* pNode)//左双
363 {
364     pNode->pLeft = RotateRight(pNode->pLeft);
365 
366     return RotateLeft(pNode);
367 }
368 
369 template <typename T>
370 AVLNode<T>* AVLTree<T>::RotateRightLeft(AVLNode<T>* pNode)//右双
371 {
372     pNode->pRight = RotateLeft(pNode->pRight);
373 
374     return RotateRight(pNode);
375 }
376 
377 // 后序遍历树以删除树
378 template <typename T>
379 void AVLTree<T>::DeleteTree(AVLNode<T>** ppRoot)
380 {
381     if (NULL == ppRoot || NULL == *ppRoot)
382         return;
383 
384     DeleteTree(&((*ppRoot)->pLeft));
385     DeleteTree(&((*ppRoot)->pRight));
386     delete ppRoot;
387     *ppRoot = NULL;
388 
389     //std::cout << "AVLTree delete completed !" << std::endl;
390 }
391 
392 template <typename T>
393 int AVLTree<T>::GetNodeCount() const
394 {
395     return nNodeCount;
396 }
397 
398 template <typename T>
399 void AVLTree<T>::Display() const
400 {
401      PrintTree(this->pRoot);
402 }
403 
404 template <typename T>
405 void AVLTree<T>::PrintTree(AVLNode<T>* pNode) const
406 {
407     if (NULL == pRoot)
408         return;
409 
410     if (NULL == pNode)
411     {
412         return;
413     }
414 
415     static int n = 0;
416     
417     if(pNode == pRoot)
418     {
419         std::cout << "[" << ++n << "]nData = " << pNode->data << ",nParentData= 0 ,";
420 
421         if(pNode->pLeft)
422             std::cout << "nLeftData= " << pNode->pLeft->data << " ,";
423         if(pNode->pRight)
424             std::cout << "nRightData= " << pNode->pRight->data << " ,";
425 
426         std::cout << "nHeight = " << pNode->nHeight << std::endl;
427     }
428     else
429     {
430         std::cout << "[" << ++n << "]nData = " << pNode->data << ",nParentData= " << pNode->pParent->data << " ,";
431 
432         if(pNode->pLeft)
433             std::cout << "nLeftData= " << pNode->pLeft->data << " ,";
434         if(pNode->pRight)
435             std::cout << "nRightData= " << pNode->pRight->data << " ,";
436 
437         std::cout << "nHeight = " << pNode->nHeight << std::endl;
438     }
439     PrintTree(pNode->pLeft);
440     PrintTree(pNode->pRight);
441 }
442 #endif    //__AVLTREE_H__

　　PS：编译和测试的方式与上面不是模板的版本一样。AVL Tree是我刚学C++不久的时候写的，存在问题在所难免。现在已经没有时间来进一步研究这个代码，放在这里做个备份，说不定什么时候就能用到呢。