因为前段时间学过一点c++的皮毛，所以想用c++来实现一下，思想上和c语言

实现的AVL树是一样的，贴出来也方便自己以后看。

  1 #ifndef _AVL_H_
  2 #define _AVL_H_
  3 
  4 #include <iomanip>
  5 #include <iostream>
  6 using namespace std;
  7 
  8 template<class T>
  9 class AVLTreeNode {
 10 public:
 11     T key;
 12     int height;
 13     AVLTreeNode *left;
 14     AVLTreeNode *right;
 15 
 16     AVLTreeNode(T value, AVLTreeNode *l, AVLTreeNode *r):
 17         key(value), height(0), left(l),right(r) {}
 18 };
 19 
 20 template<class T>
 21 class AVLTree{
 22 private:
 23     AVLTreeNode<T> *mRoot;
 24 public:
 25     AVLTree();  //无参构造函数
 26     ~AVLTree(); //析构函数
 27 
 28     int height();  //求树的高度
 29     int max(int a, int b);
 30     
 31     void preOrder(); //前序遍历
 32     void inOrder(); //中序遍历
 33     void postOrder(); //后序遍历
 34     
 35     AVLTreeNode<T>* search(T key);  //查找
 36     AVLTreeNode<T>* iterativeSearch(T key); //非递归查找
 37 
 38     T minimun(); //获得树的最小值
 39     T maximum(); //获得树的最大值
 40 
 41     void insert(T key); //插入值
 42     void remove(T key); //移除某个
 43 
 44     void destroy(); //销毁树
 45     void print(); //打印avl树
 46 
 47 private:
 48     int height(AVLTreeNode<T>* tree); //获取树的高度
 49     void preOrder(AVLTreeNode<T>* tree) const;
 50     void inOrder(AVLTreeNode<T>* tree) const;
 51     void postOrder(AVLTreeNode<T>* tree) const;
 52 
 53     AVLTreeNode<T>* search(AVLTreeNode<T>* x, T key) const;
 54     AVLTreeNode<T>* iterativeSearch(AVLTreeNode<T> *, T key) const;
 55 
 56     AVLTreeNode<T>* minimun(AVLTreeNode<T>* x);
 57     AVLTreeNode<T>* maximum(AVLTreeNode<T>* x);
 58 
 59     AVLTreeNode<T>* leftLeftRotation(AVLTreeNode<T>* k2);
 60     AVLTreeNode<T>* rightRightRotation(AVLTreeNode<T>* k1);
 61     AVLTreeNode<T>* leftRightRotation(AVLTreeNode<T>* k3);
 62     AVLTreeNode<T>* rightLeftRotation(AVLTreeNode<T>* k1);
 63 
 64     AVLTreeNode<T>* insert(AVLTreeNode<T>* &tree, T key);
 65     AVLTreeNode<T>* remove(AVLTreeNode<T>* &tree, AVLTreeNode<T>* z);
 66 
 67     void destroy(AVLTreeNode<T>* &tree);
 68     void print(AVLTreeNode<T>* tree, T key, int direction);
 69 };
 70 
 71 template<class T>
 72 AVLTree<T>::AVLTree():mRoot(NULL)
 73 {
 74 }
 75 
 76 template<class T>
 77 AVLTree<T>::~AVLTree()
 78 {
 79     destroy(mRoot);
 80 }
 81 
 82 template<class T>
 83 AVLTree<T>::height(AVLTreeNode<T>* tree)
 84 {
 85     if(tree != NULL)    
 86         return tree->height;
 87     return 0;
 88 }
 89 
 90 template<class T>
 91 int AVLTree<T>::height()  //public 的函数不应该对私有的进行操作
 92 {
 93     return height(mRoot);
 94 }
 95 
 96 template<class T>
 97 int AVLTree<T>::max(int a, int b)
 98 {
 99     return a > b ? a : b;
100 }
101 
102 template<class T>
103 void AVLTree<T>::preOrder(AVLTreeNode<T>* tree) const
104 {
105     if(tree != NULL)
106     {
107         cout<<tree->key<<" ";
108         preOrder(tree->left);
109         preOrder(tree->right);
110     }
111 } 
112 
113 template<class T>
114 void AVLTree<T>::preOrder()
115 {
116     preOrder(mRoot);
117 }
118 
119 template<class T>
120 void AVLTree<T>::inOrder(AVLTreeNode<T>* tree) const
121 {
122     if(tree != NULL)
123     {
124         inOrder(tree->left);
125         cout<<tree->key<<" ";
126         inOrder(tree->right);
127     }
128 }
129 
130 template<class T>
131 void AVLTree<T>::inOrder()
132 {
133     inOrder(mRoot);
134 }
135 
136 template<class T>
137 void AVLTree<T>::postOrder(AVLTreeNode<T>* tree) const
138 {
139     if(tree != NULL)
140     {
141         postOrder(tree->left);
142         postOrder(tree->right);
143         cout<<tree->key<<" ";
144     }
145 }
146 
147 template<class T>
148 void AVLTree<T>::postOrder()
149 {
150     postOrder(mRoot);
151 }
152 
153 template<class T>
154 AVLTreeNode<T>* AVLTree<T>::search(AVLTreeNode<T>* x, T key) const
155 {
156     if(x == NULL || x->key == key)
157         return x;
158     if(key < x->key)
159         return search(x->left, key);
160     else 
161         return search(x->right, key);
162 }
163 
164 template<class T>
165 AVLTreeNode<T>* AVLTree<T>::search(T key)
166 {
167     return search(mRoot, key);
168 }
169 
170 template<class T>
171 AVLTreeNode<T>* AVLTree<T>::iterativeSearch(AVLTreeNode<T>* x, T key) const
172 {
173     while((x != NULL) && (x->key != key))
174     {
175         if(key < x->key)
176             x = x->left;
177         else 
178             x = x->right;
179     }
180     return x;
181 }
182 
183 template<class T>
184 AVLTreeNode<T>* AVLTree<T>::iterativeSearch(T key)
185 {
186     return iterativeSearch(mRoot, key);
187 }
188 
189 template<class T>
190 AVLTreeNode<T>* AVLTree<T>::minimun(AVLTreeNode<T>* tree)
191 {
192     if(tree == NULL)
193         return NULL;
194     while(tree->left != NULL)
195         tree = tree->left;
196     return tree;
197 }
198 
199 template<class T>
200 T AVLTree<T>::minimun()
201 {
202     AVLTreeNode<T> *p = minimun(mRoot);
203     if(p != NULL)
204         return p->key;
205     return (T)NULL;
206 }
207 
208 template<class T>
209 AVLTreeNode<T>* AVLTree<T>::maximum(AVLTreeNode<T> *tree)
210 {
211     if(tree == NULL)
212         return NULL;
213     while(tree->right != NULL)
214         tree = tree->right;
215     return tree;
216 }
217 
218 template<class T>
219 T AVLTree<T>::maximum()
220 {
221     AVLTreeNode<T> *p = maximum(mRoot);
222     if(p != NULL)
223         return p->key;
224     return (T)NULL;
225 }
226 
227 template<class T>
228 AVLTreeNode<T>* AVLTree<T>::leftLeftRotation(AVLTreeNode<T>* k2)
229 {
230     AVLTreeNode<T> *k1;
231 
232     k1 = k2->left;
233     k2->left = k1->right;
234     k1->right = k2;
235 
236     k2->height = max(height(k2->left), height(k2->right)) + 1;
237     k1->height = max(height(k1->left), k2->height) + 1;
238     return k1;
239 }
240 
241 template<class T>
242 AVLTreeNode<T>* AVLTree<T>::rightRightRotation(AVLTreeNode<T>* k1)
243 {
244     AVLTreeNode<T>* k2;
245 
246     k2 = k1->right;
247     k1->right = k2->left;
248     k2->left = k1;
249 
250     k1->height = max(height(k1->left), height(k1->right)) + 1;
251     k2->height = max(height(k2->right), k1->height) + 1;
252 
253     return k2;
254 }
255 
256 template<class T>
257 AVLTreeNode<T>* AVLTree<T>::leftRightRotation(AVLTreeNode<T> *k3)
258 {
259     k3->left = rightRightRotation(k3->left);
260     return leftLeftRotation(k3);
261 }
262 
263 template<class T>
264 AVLTreeNode<T>* AVLTree<T>::rightLeftRotation(AVLTreeNode<T> *k3)
265 {
266     k3->right = leftLeftRotation(k3->right);
267     return rightRightRotation(k3);
268 }
269 
270 template<class T>
271 AVLTreeNode<T>* AVLTree<T>::insert(AVLTreeNode<T>* &tree, T key)
272 {
273     if(tree == NULL)
274     {
275         tree = new AVLTreeNode<T>(key, NULL, NULL);
276         if(tree == NULL)
277         {
278             cout<<"ERROR: create avltree node failed!"<<endl;
279             return NULL;
280         }
281     } else if(key < tree->key)
282     {
283         tree->left = insert(tree->left, key);
284         if(height(tree->left) - height(tree->right) == 2)
285         {
286             if(key < tree->left->key)
287                 tree = leftLeftRotation(tree);
288             else   
289                 tree = leftRightRotation(tree);
290         }
291     } else if(key > tree->key)
292     {
293         tree->right = insert(tree->right, key);
294         if(height(tree->right) - height(tree->left) == 2)
295         {
296             if(key > tree->right->key)
297                 tree = rightRightRotation(tree);
298             else 
299                 tree = rightLeftRotation(tree);
300         }
301     } else
302     {
303         cout<<"add error: not allow add same node!" <<endl;
304     }
305 
306     tree->height = max(height(tree->left), height(tree->right)) + 1;
307     return tree;
308 }
309 
310 template<class T>
311 void AVLTree<T>::insert(T key)
312 {
313     insert(mRoot, key);
314 }
315 
316 template<class T>
317 AVLTreeNode<T>* AVLTree<T>::remove(AVLTreeNode<T>* &tree, AVLTreeNode<T>* z)
318 {
319     if(tree == NULL || z == NULL)
320         return NULL;
321     if(z->key < tree->key)
322     {
323         tree->left = remove(tree->left, z);
324         if(height(tree->right) - height(tree->left) == 2)
325         {
326             AVLTreeNode<T> *r = tree->right;
327             if(height(r->left) > height(r->right))
328                 tree = rightLeftRotation(tree);
329             else 
330                 tree = rightRightRotation(tree);
331         }
332     } else if(z->key > tree->key) 
333     {
334         tree->right = remove(tree->right, z);
335         if(height(tree->left) - height(tree->right) == 2)
336         {
337             AVLTreeNode<T> *l = tree->left;
338             if(height(l->right) > height(l->left))
339                 tree = leftRightRotation(tree);
340             else 
341                 tree = leftLeftRotation(tree);
342         }
343     } else 
344     {
345         if((tree->left != NULL) && (tree->right != NULL))
346         {
347             if(height(tree->left) > height(tree->right))
348             {
349                 AVLTreeNode<T>* max = maximum(tree->left);
350                 tree->key = max->key;
351                 tree->left = remove(tree->left, max);
352             } else 
353             {
354                 AVLTreeNode<T>* min = minimun(tree->right);
355                 tree->key = min->key;
356                 tree->left = remove(tree->right, min);
357             }
358         } else {
359             AVLTreeNode<T>* tmp = tree;
360             tree = (tree->left!=NULL) ? tree->left : tree->right;
361             delete tmp;
362         }
363     }
364     return tree;
365 }
366 
367 template<class T>
368 void AVLTree<T>::remove(T key)
369 {
370     AVLTreeNode<T>* z;
371     if((z = search(mRoot, key)) != NULL)
372         mRoot = remove(mRoot, z);
373 }
374 
375 template<class T>
376 void AVLTree<T>::destroy(AVLTreeNode<T>* &tree)
377 {
378     if(tree == NULL)
379         return;
380     if(tree->left != NULL)
381         destroy(tree->left);
382     if(tree->right != NULL)
383         destroy(tree->right);
384     delete tree;
385 }
386 
387 template<class T>
388 void AVLTree<T>::destroy()
389 {
390     destroy(mRoot);
391 }
392 
393 template<class T>
394 void AVLTree<T>::print(AVLTreeNode<T>* tree, T key, int direction)
395 {
396     if(tree != NULL)
397     {
398         if(direction==0)    // tree是根节点
399             cout << setw(2) << tree->key << " is root" << endl;
400         else                // tree是分支节点
401             cout << setw(2) << tree->key << " is " << setw(2) << key << "'s "  << setw(12) << (direction==1?"right child" : "left child") << endl;
402     
403         print(tree->left, tree->key, -1);
404         print(tree->right,tree->key,  1);
405     }
406 }
407 
408 template<class T>
409 void AVLTree<T>::print()
410 {
411     if(mRoot != NULL)
412         print(mRoot, mRoot->key, 0);
413 }
414 
415 #endif
avltree.h
 1 #include <iostream>
 2 #include "avl.h"
 3 
 4 using namespace std;
 5 
 6 static int arr[]= {3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9};
 7 #define TBL_SIZE(a) ( (sizeof(a)) / (sizeof(a[0])) )
 8 
 9 int main()
10 {
11     int i, ilen;
12     AVLTree<int>* tree = new AVLTree<int>();
13 
14     cout<<"==follow add: ";
15     ilen = TBL_SIZE(arr);
16     for(i = 0; i < ilen; i++)
17     {
18         cout<<arr[i]<< " ";
19         tree->insert(arr[i]);
20     }
21 
22     cout<<"\n==preorder: ";
23     tree->preOrder();
24     cout<<"\n==inorder: ";
25     tree->inOrder();
26     cout<<"\n==postorder: ";
27     tree->postOrder();
28     cout<<endl;
29     cout<<"==height: " << tree->height() <<endl;
30     cout<<"==the information of tree is: "<<endl;
31     tree->print();
32 
33     i = 8;
34     tree->remove(i);
35     cout<<"\n==inorder: ";
36     tree->inOrder();
37 
38     tree->destroy();
39     
40     char c;
41     cin>>c;
42     return 0;
43 }
avltreeTest.cpp

测试结果如图所示：