AVL树（数据结构与算法分析代码）

AVL树是带有平衡条件的二叉查找树。

一棵AVL树是其每个结点的左右子树和右子树的高度最多差1的二叉查找树。（空树的高度定义为-1）。

AVL树是通过单旋转或者双旋转保持平衡性质。

PS：只是贴上代码（严格来说是保存代码。。。。），日后会贴上图片，方便理解。。。。。。。。

View Code

  1 #include<iostream>
  2 using namespace std;
  3 
  4 template <typename Object>
  5 class AVLTree
  6 {
  7 private:
  8     struct AVLNode
  9     {
 10         Object data;
 11         AVLNode * left;
 12         AVLNode * right;
 13         int height;
 14 
 15         AVLNode( const Object & d = Object(), AVLNode *l = NULL , AVLNode *r = NULL, int h = 0)
 16             : data( d ), left( l ), right( r ), height( h )
 17         { }
 18     };
 19 
 20 
 21 public:
 22     AVLTree( )
 23     {
 24         root = NULL;
 25     }
 26 
 27     AVLTree( const AVLTree & rhs )
 28     {
 29         root = rhs.root;
 30     }
 31     ~AVLTree( )
 32     {
 33         makeEmpty( );
 34     }
 35 
 36     bool isEmpty( ) const
 37     {
 38         if( root == NULL )
 39             return true;
 40         else
 41             return false;
 42     }
 43 
 44 
 45     const Object & findMin( ) const
 46     {
 47         return findMin( root );
 48     }
 49 
 50     const Object & findMax( ) const
 51     {
 52         return findMax( root );
 53     }
 54 
 55     bool contains( const Object & x ) const
 56     {
 57         return contains( x, root );
 58     }
 59 
 60     void insert( const Object  & x )
 61     {
 62         insert( x, root );
 63     }
 64 
 65     void remove( const Object & x )
 66     {
 67         remove( x, root );
 68     }
 69 
 70     void makeEmpty( )
 71     {
 72         makeEmpty( root );
 73     }
 74 
 75     void preRecursive( )
 76     {
 77         preRecursive( root );
 78     }
 79 
 80 private:
 81     AVLNode * root;
 82 
 83     int height( AVLNode * t ) const
 84     {
 85         //return t == NULL ? -1 : t->height;
 86         if(t == NULL)
 87             return -1;
 88 
 89         return t->height;
 90     }
 91 
 92     AVLNode * findMin( AVLNode * t ) const
 93     {
 94         if( t == NULL )
 95             return NULL;
 96         if( t->left == NULL )
 97             return t;
 98         return findMin( t->left );
 99     }
100 
101     AVLNode * findMax( AVLNode * t ) const
102     {
103         if( t == NULL )
104             return NULL;
105         if( t->right == NULL )
106             return t;
107         return findMax( t->right );
108     }
109 
110     bool contains ( const Object & x, AVLNode * t ) const
111     {
112         if( t == NULL )
113             return false;
114         else if( x < t->data )
115             return contains( x, t->left );
116         else if( x > t->data )
117             return contains( x, t->right );
118         else
119             return true;
120     }
121 
122     void insert( const Object & x, AVLNode * & t )
123     {
124         if( t == NULL )
125         {
126             t = new AVLNode( );
127             t->data = x;
128             t->left = t->right = NULL;
129 
130             t = new AVLNode( x, NULL, NULL );
131         }
132 
133         else if ( x < t->data )
134         {
135             insert( x, t->left );
136             if( height( t->left ) - height( t->right ) == 2 )
137             {
138                 if( x < t->left->data )
139                     rotateWithLeftChild( t );
140                 else
141                     doubleWithLeftChild( t );
142             }
143         }
144 
145         else if ( x > t->data )
146         {
147             insert( x, t->right );
148             if( height( t->right) - height( t->left ) == 2 )
149             {
150                 if( x > t->right->data )
151                     rotateWithRightChild( t );
152                 else
153                     doubleWithRightChild( t );
154             }
155         }
156 
157         else
158             ;
159 
160         t->height = max( height( t->left ), height( t->right ) ) + 1;
161     }
162 
163     void rotateWithLeftChild( AVLNode * & x )
164     {
165         AVLNode * y = x->left;
166         x->left = y->right;
167         y->right = x;
168         x->height = max( height(x->left), height(x->right) ) + 1;
169         y->height = max( height(y->left), x->height ) + 1;
170         x = y;
171     }
172 
173     void rotateWithRightChild( AVLNode * & x )
174     {
175         AVLNode * y = x->right;
176         x->right = y->left;
177         y->left = x;
178         x->height = max( height(x->left), height(x->right) ) + 1;
179         y->height = max( height(y->right), x->height ) + 1;
180         x = y;
181     }
182 
183     void doubleWithLeftChild( AVLNode * & x )
184     {
185         rotateWithRightChild(x->left);
186         rotateWithLeftChild(x);
187     }
188 
189     void doubleWithRightChild( AVLNode * & x )
190     {
191         rotateWithLeftChild(x->right);
192         rotateWithRightChild(x);
193     }
194 
195     void remove( const Object & x, AVLNode * & t ) const
196     {
197         if( t == NULL )
198             return ;
199         if( x < t->data )
200             remove( x, t->left );
201         else if( x > t->data )
202             remove( x, t->right );
203         else if( t->left != NULL && t->right != NULL )
204         {
205             t->data = findMin( t->right )->data;
206             remove( t->data, t->right );
207         }
208         else
209         {
210             AVLNode * oldNode = t;
211             t = ( t->left != NULL ) ? t->left : t->right;
212             delete oldNode;
213         }
214     }
215 
216     void makeEmpty( AVLNode * & t ) const
217     {
218         if( t != NULL )
219         {
220             makeEmpty( t->left );
221             makeEmpty( t->right );
222             delete t;
223         }
224         t = NULL;
225     }
226 
227     void preRecursive( AVLNode * &T ) const
228     {
229         if( T != NULL )
230         {
231             cout << T->data << " ";
232             preRecursive( T->left );
233             preRecursive( T->right );
234         }
235     }
236 
237 };
238 
239 int main()
240 {
241     AVLTree<int> tree;
242     int n, m;
243     cin >> n;
244     cout << endl;
245     for(int i = 1; i <= n; ++i)
246     {
247         cin >> m;
248         tree.insert( m );
249         //tree.preRecursive();
250         //cout << endl;
251     }
252     tree.preRecursive();
253     /*tree.insert(7);
254     tree.insert(13);
255     tree.insert(3);
256     tree.insert(2);
257     tree.preRecursive();*/
258     return 0;
259 }

 

转载于:https://www.cnblogs.com/alan-forever/archive/2012/12/04/2802054.html