My implementation of AVL tree

  1 #include <stdlib.h>
  2 #include <time.h>
  3 #include <string.h>
  4 #include <vector>
  5 #include <stdio.h>
  6 
  7 using namespace std;
  8 
  9 class AvlNode
 10 {
 11  public :
 12     int data;
 13     AvlNode *parent;
 14     AvlNode *left;
 15     AvlNode *right;
 16     int height;
 17     int cx;
 18     int cy;
 19     AvlNode()
 20     {
 21         left = right = parent = NULL;
 22         height = 1;
 23         cx = cy = data = 0;
 24     }
 25 
 26 };
 27 
 28 class AvlTree
 29 {
 30 public :
 31     AvlNode *root;
 32     void rotateR(AvlNode *node);
 33     void rotateL(AvlNode *node);
 34     int getChildHeight(AvlNode *node);
 35     int getNodeHeight(AvlNode *node);
 36     int getBal(AvlNode *node);
 37     void recallBalancing(AvlNode *node);
 38     void insertValue(const int value);
 39     void preTravel(const AvlNode *node,vector<int> &vec);
 40     void postTravel(const AvlNode *node, vector<int> &vec);
 41     void midTravel(const AvlNode *node, vector<int> &vec);
 42     AvlTree() : root(NULL) {} ;
 43 };
 44 
 45 
 46 int AvlTree::getNodeHeight(AvlNode *node)
 47 {
 48     if (node == NULL) return 0;
 49     return getNodeHeight(node->left) - getNodeHeight(node->right);
 50 }
 51 
 52 static inline int Max(const int a, const int b)
 53 {
 54     return (a>b)?a:b;
 55 }
 56 
 57 int AvlTree::getBal(AvlNode *node)
 58 {
 59     if (node == NULL) return 0;
 60     return getNodeHeight(node->left) - getNodeHeight(node->right);
 61 }
 62 
 63 void AvlTree::preTravel(const AvlNode *node, vector<int> &vec)
 64 {
 65     if (node == NULL) return;
 66     vec.push_back(node->data);
 67     preTravel(node->left, vec);
 68     preTravel(node->right, vec);
 69 }
 70 
 71 void AvlTree::midTravel(const AvlNode *node, vector<int> &vec)
 72 {
 73     if (node == NULL) return;
 74     midTravel(node->left, vec);
 75     vec.push_back(node->data);
 76     midTravel(node->right, vec);
 77 }
 78 
 79 void AvlTree::postTravel(const AvlNode *node, vector<int> &vec)
 80 {
 81     if (node == NULL) return;
 82     postTravel(node->left, vec);
 83     postTravel(node->right, vec);
 84     vec.push_back(node->data);
 85 }
 86 
 87 void AvlTree::insertValue(const int value)
 88 {
 89     AvlNode *cursor = root;
 90     if (cursor == NULL)  {
 91         AvlNode *node = new AvlNode;
 92         node->data = value;
 93         root = node;
 94         return;
 95     }
 96 
 97     int ret;
 98     //printf("begin while\n");
 99     while (cursor != NULL)  {
100         ret = cursor->data;
101        // printf("%d %d\n",value,ret);
102         if (value < ret)  {
103             if (cursor->left == NULL)   {
104                 AvlNode *node = new AvlNode;
105                 node->data = value;
106                 node->parent = cursor;
107                 cursor->left = node;
108                 break;
109             }
110             cursor = cursor->left;
111         }
112         else if (value > ret) {
113             if (cursor->right == NULL)  {
114                 AvlNode *node = new AvlNode;
115                 node->data = value;
116                 node->parent = cursor;
117                 cursor->right = node;
118                 break;
119             }
120             cursor = cursor->right;
121         }
122         else {
123             return;
124         }
125     } // while
126     recallBalancing(cursor);
127 }
128 
129 
130 
131 int AvlTree::getChildHeight(AvlNode *node)
132 {
133     return Max(getNodeHeight(node->left), getNodeHeight(node->right));
134 }
135 
136 void AvlTree::recallBalancing(AvlNode *node)
137 {
138     AvlNode *cursor = node;
139     int bal;
140    // printf("Begin balancing\n");
141     while (cursor != NULL)
142     {
143         bal = getBal(cursor);
144         if (bal == 0) {
145             return;
146         }
147         else if (bal == -1 || bal == 1) {
148             cursor->height = getChildHeight(cursor) + 1;
149             cursor = cursor->parent;
150         }
151         else if (bal > 1) {
152             bal = getBal(cursor->left);
153             if (bal < 0)
154                 rotateL(cursor->left);
155             rotateR(cursor);
156             return;
157         }
158         else {
159             bal = getBal(cursor->right);
160             if (bal > 0)
161                 rotateR(cursor->right);
162             rotateL(cursor);
163             return;
164         }
165     }
166    // printf("End balance\n");
167 }
168 
169 
170 void AvlTree::rotateL(AvlNode *node)
171 {
172    AvlNode*pivot = node->right;
173     pivot->height = node->height;
174     node->height--;
175    AvlNode*parent = node->parent;
176 
177     node->right = pivot->left;
178     if (pivot->left)
179        pivot->left->parent = node;
180     pivot->left = node;
181     node->parent = pivot;
182 
183     pivot->parent = parent;
184     if (parent)
185     {
186         if (parent->left == node)
187               parent->left = pivot;
188         else  parent->right = pivot;
189     }
190     else
191     {
192         // parent == NULL retur new root
193         root = pivot;
194     }
195 }
196 
197 void AvlTree::rotateR(AvlNode *node)
198 {
199    AvlNode*pivot = node->left;
200     pivot->height = node->height;
201     node->height--;
202    AvlNode*parent = node->parent;
203 
204     node->left = pivot->right;
205     if (pivot->right)
206        pivot->right->parent = node;
207     pivot->right = node;
208     node->parent = pivot;
209 
210     pivot->parent = parent;
211     if (parent)
212     {
213         if (parent->left == node)
214                parent->left = pivot;
215         else   parent->right = pivot;
216     }
217     else
218     {
219         // parent == NULL retur new root
220         root = pivot;
221     }
222 }
223 
224 
225 
226 int main(int argc,char **argv)
227 {
228     AvlTree avltree;
229     vector<int> vec;
230 
231     srand(time(NULL));
232     int i;
233     for (i=0; i < 32; i++)
234         avltree.insertValue(rand()%999);
235     avltree.midTravel(avltree.root, vec);
236     for (auto elem : vec) {
237         printf("%d ", elem);
238     }
239 
240     return 0;
241 }