AVL的实现

Posted 2021-01-25 gebicungaha

  1 #include "stdafx.h"
  2 
  3 /*
  4 * @author Wu Jingan
  5 * @created June 6, 2018
  6 */
  7 
  8 #include <iostream>
  9 #include <string>
 10 #include <algorithm>
 11 #include <ctime>
 12 #include <Windows.h>
 13 #include <vector>
 14 using namespace std;
 15 
 16 class Node
 17 {
 18 public:
 19     Node() {}
 20     Node(int value, Node *parent, Node *left, Node *right)
 21     {
 22         this->value = value;
 23         this->parent = parent;
 24         this->left = left;
 25         this->right = right;
 26     }
 27 
 28     Node operator=(const Node &_Right)
 29     {
 30         this->value = _Right.value;
 31         this->parent = _Right.parent;
 32         this->right = _Right.right;
 33         this->left = _Right.left;
 34         return *this;
 35     }
 36 
 37     bool isLeaf()
 38     {
 39         return this->left == nullptr && this->right == nullptr;
 40     }
 41 
 42     int value;
 43     Node *parent;
 44     Node *left;
 45     Node *right;
 46 };
 47 
 48 class AbstractBinarySearchTree
 49 {
 50 public:
 51     int getMinimumNodeValue()
 52     {
 53         return getMinimumNode(root)->value;
 54     }
 55 
 56     int getMaximumNodeValue()
 57     {
 58         return getMaximumNode(root)->value;
 59     }
 60 
 61     int getSize()
 62     {
 63         return this->size;
 64     }
 65 
 66     //若元素不存在, 返回1
 67     bool isContains(int element)
 68     {
 69         return search(element) == nullptr;
 70     }
 71 
 72     //先序遍历二叉搜索树
 73     void printtAbstractBinarySearchTreePreOrder(Node *root)
 74     {
 75         if (root == nullptr)
 76             return;
 77         cout << root->value << " ";
 78         printtAbstractBinarySearchTreePreOrder(root->left);
 79         printtAbstractBinarySearchTreePreOrder(root->right);
 80     }
 81 
 82     //中序遍历二叉搜索树
 83     void printtAbstractBinarySearchTreeInOrder(Node *root)
 84     {
 85         if (root == nullptr)
 86             return;
 87         printtAbstractBinarySearchTreeInOrder(root->left);
 88         cout << root->value << " ";
 89         printtAbstractBinarySearchTreeInOrder(root->right);
 90     }
 91 
 92     //后序遍历二叉搜索树
 93     void printtAbstractBinarySearchTreePostOrder(Node *root)
 94     {
 95         if (root == nullptr)
 96             return;
 97         printtAbstractBinarySearchTreePostOrder(root->left);
 98         printtAbstractBinarySearchTreePostOrder(root->right);
 99         cout << root->value << " ";
100     }
101 
102     void printTree()
103     {
104         printSubtree(root);
105     }
106 
107 protected:
108     Node * createNode(int value, Node *parent, Node *left, Node *right)
109     {
110         Node *node = new Node(value, parent, left, right);
111         return node;
112     }
113 
114     Node * deleteNode(int element)
115     {
116         Node *node = search(element);
117         if (node != nullptr)
118             return deleteNode(node);
119         else
120             return nullptr;
121     }
122 
123     Node *search(int element)
124     {
125         Node *node = root;
126         while (node != nullptr && node->value != element)
127         {
128             if (node->value < element)
129                 node = node->right;
130             else
131                 node = node->left;
132         }
133         return node;
134     }
135 
136     Node *insertNode(int element)
137     {
138         if (root == nullptr)
139         {
140             root = createNode(element, nullptr, nullptr, nullptr);
141             size++;
142             return root;
143         }
144         Node *insertParentNode = root;
145         Node *searchTempNode = root;
146         while (searchTempNode != nullptr)
147         {
148             insertParentNode = searchTempNode;
149             if (element < searchTempNode->value)
150                 searchTempNode = searchTempNode->left;
151             else if (element > searchTempNode->value)
152                 searchTempNode = searchTempNode->right;
153             else
154                 return searchTempNode;
155         }
156         Node *NewNode = createNode(element, insertParentNode, nullptr, nullptr);
157         if (insertParentNode->value > element)
158             insertParentNode->left = NewNode;
159         else
160             insertParentNode->right = NewNode;
161         size++;
162         return NewNode;
163     }
164 
165     Node * deleteNode(Node *deleteNode)
166     {
167         Node *nodeToReturn = nullptr;
168         if (deleteNode != nullptr)
169         {
170             if (deleteNode->left == nullptr)
171                 nodeToReturn = transplantNode(deleteNode, deleteNode->right);
172             else if (deleteNode->right == nullptr)
173                 nodeToReturn = transplantNode(deleteNode, deleteNode->left);
174             else
175             {
176                 Node *successorNode = getMinimumNode(deleteNode->right);
177                 if (successorNode->parent != deleteNode)
178                 {
179                     transplantNode(successorNode, successorNode->right);
180                     successorNode->right = deleteNode->right;
181                     successorNode->right->parent = successorNode;
182                 }
183                 transplantNode(deleteNode, successorNode);
184                 successorNode->left = deleteNode->left;
185                 successorNode->left->parent = successorNode;
186                 nodeToReturn = successorNode;
187             }
188             size--;
189             return nodeToReturn;
190         }
191         else
192             return nullptr;
193     }
194 
195     Node *transplantNode(Node *nodeToReplace, Node *newNode)
196     {
197         if (nodeToReplace->parent == nullptr)
198             this->root = newNode;
199         else if (nodeToReplace == nodeToReplace->parent->left)
200             nodeToReplace->parent->left = newNode;
201         else
202             nodeToReplace->parent->right = newNode;
203         if (newNode != nullptr)
204             newNode->parent = nodeToReplace->parent;
205         return newNode;
206     }
207 
208     void printNodeValue(Node *node)
209     {
210         if (node == nullptr)
211             cout << "<null>";
212         else
213             cout << node->value;
214         cout << endl;
215     }
216 
217     void printSubtree(Node *node)
218     {
219         if (node->right != nullptr) {
220             printTree(node->right, true, "");
221         }
222         printNodeValue(node);
223         if (node->left != nullptr) {
224             printTree(node->left, false, "");
225         }
226     }
227 
228     void printTree(Node *node, bool isRight, string indent)
229     {
230         if (node->right != nullptr)
231             printTree(node->right, true, indent + (isRight ? "        " : " |      "));
232         cout << indent;
233         if (isRight)
234             cout << " /";
235         else
236             cout << " \";
237         cout << "----- ";
238         printNodeValue(node);
239         if (node->left != nullptr)
240             printTree(node->left, false, indent + (isRight ? " |      " : "        "));
241     }
242 
243     Node *getMinimumNode(Node *node)
244     {
245         while (node->left != nullptr)
246             node = node->left;
247         return node;
248     }
249 
250     Node *getMaximumNode(Node *node)
251     {
252         while (node->right != nullptr)
253             node = node->right;
254         return node;
255     }
256 
257     Node *root = nullptr;
258     int size;
259 };
260 
261 class AbstractSelfBalancingBinarySearchTree :public AbstractBinarySearchTree
262 {
263 protected:
264     Node * rotateLeft(Node *node)
265     {
266         Node *tempNode = node->right;
267         tempNode->parent = node->parent;
268         node->right = tempNode->left;
269         if (node->right != nullptr)
270             node->right->parent = node;
271         tempNode->left = node;
272         node->parent = tempNode;
273         if (tempNode->parent != nullptr)
274         {
275             if (node == tempNode->parent->left)
276                 tempNode->parent->left = tempNode;
277             else
278                 tempNode->parent->right = tempNode;
279         }
280         else
281             root = tempNode;
282         return tempNode;
283     }
284 
285     Node *rotateRight(Node *node) 
286     {
287         Node * tempNode = node->left;
288         tempNode->parent = node->parent;
289         node->left = tempNode->right;
290         if (node->left != nullptr)
291             node->left->parent = node;
292 
293         tempNode->right = node;
294         node->parent = tempNode;
295         if (tempNode->parent != nullptr)
296         {
297             if (node == tempNode->parent->left)
298                 tempNode->parent->left = tempNode;
299             else
300                 tempNode->parent->right = tempNode;
301         }
302         else
303             root = tempNode;
304         return tempNode;
305     }
306 };
307 
308 class AVLNode :public Node
309 {
310 public:
311     AVLNode(int value, Node *parent, Node *left, Node *right)
312     {
313         Node(value, parent, left, right);
314     }
315 
316     int height;
317 };
318 
319 class AVLTree :public AbstractSelfBalancingBinarySearchTree
320 {
321 public:
322     Node * insert(int element)
323     {
324         Node *newNode = this->insertNode(element);
325         rebalance((AVLNode *)newNode);
326         return newNode;
327     }
328 
329     Node *deleteAVLNode(int element)
330     {
331         Node *delete_Node = AbstractSelfBalancingBinarySearchTree::search(element);
332         if (delete_Node != nullptr)
333         {
334             Node *successorNode = AbstractSelfBalancingBinarySearchTree::deleteNode(delete_Node);
335             if (successorNode != nullptr)
336             {
337                 AVLNode *minimum = successorNode->right != nullptr ? (AVLNode *)getMinimumNode(successorNode->right) : (AVLNode *)successorNode;
338                 recomputeHeight(minimum);
339                 rebalance((AVLNode *)minimum);
340             }
341             else
342             {
343                 recomputeHeight((AVLNode *)delete_Node->parent);
344                 rebalance((AVLNode *)delete_Node->parent);
345             }
346             return successorNode;
347         }
348         return nullptr;
349     }
350 
351 protected:
352     Node * createNode(int value, Node *parent, Node *left, Node *right)
353     {
354         return new AVLNode(value, parent, left, right);
355     }
356 
357     Node * doubleRotateRightLeft(Node *node)
358     {
359         node->right = avlRotateRight(node->right);
360         return avlRotateLeft(node);
361     }
362 
363     Node * doubleRotateLeftRight(Node *node)
364     {
365         node->left = avlRotateLeft(node->left);
366         return avlRotateRight(node);
367     }
368 
369 private:
370     void rebalance(AVLNode *node)
371     {
372         while (node != nullptr)
373         {
374             Node *parent = node->parent;
375 
376             int leftHeight = (node->left == nullptr) ? -1 : ((AVLNode *)node->left)->height;
377             int rightHeight = (node->right == nullptr) ? -1 : ((AVLNode *)node->right)->height;
378             int nodeBalance = leftHeight - rightHeight;
379             if (nodeBalance == -2)
380             {
381                 if (node->right->right != nullptr) 
382                 {
383                     node = (AVLNode *)avlRotateLeft(node);
384                     break;
385                 }
386                 else 
387                 {
388                     node = (AVLNode *)doubleRotateRightLeft(node);
389                     break;
390                 }
391             }
392             else if (nodeBalance == 2)
393             {
394                 if (node->left->left != nullptr)
395                 {
396                     node = (AVLNode *)avlRotateRight(node);
397                     break;
398                 }
399                 else
400                 {
401                     node = (AVLNode *)doubleRotateLeftRight(node);
402                     break;
403                 }
404             }
405             else 
406                 updateHeight(node);
407             node = (AVLNode*)parent;
408         }
409 
410     }
411     
412     void recomputeHeight(AVLNode *node)
413     {
414         while (node != nullptr)
415         {
416             node->height = maxHeight((AVLNode *)node->left, (AVLNode *)node->right) + 1;
417             node = (AVLNode *)node->parent;
418         }
419     }
420 
421     int maxHeight(AVLNode *_LeftNode, AVLNode *_RightNode)
422     {
423         if (_LeftNode != nullptr && _RightNode != nullptr)
424             return _LeftNode->height > _RightNode->height ? _LeftNode->height : _RightNode->height;
425         else if (_LeftNode == nullptr)
426             return _RightNode != nullptr ? _RightNode->height : -1;
427         else if (_RightNode == nullptr)
428             return _LeftNode != nullptr ? _LeftNode->height : -1;
429         return -1;
430     }
431 
432     Node * avlRotateLeft(Node *node)
433     {
434         Node *temp = AbstractSelfBalancingBinarySearchTree::rotateLeft(node);
435         updateHeight((AVLNode *)temp->left);
436         updateHeight((AVLNode *)temp);
437         return temp;
438     }
439 
440     Node * avlRotateRight(Node *node) 
441     {
442         Node *temp = AbstractSelfBalancingBinarySearchTree::rotateRight(node);
443 
444         updateHeight((AVLNode *)temp->right);
445         updateHeight((AVLNode *)temp);
446         return temp;
447     }
448 
449     void updateHeight(AVLNode *node)
450     {
451         int leftHeight = (node->left == nullptr) ? -1 : ((AVLNode *)node->left)->height;
452         int rightHeight = (node->right == nullptr) ? -1 : ((AVLNode *)node->right)->height;
453         node->height = max(leftHeight, rightHeight) + 1;
454     }
455 };
456 
457 //for test
458 class RandomArray
459 {
460 public:
461     RandomArray() { }
462     RandomArray(int maxValue, int maxSize)
463     {
464         this->maxValue = maxValue;
465         this->maxSize = maxSize;
466         this->randomVec = new vector<int>(rand() % maxSize + 5);
467     }
468 
469     vector<int> *getRandomArray()
470     {
471         for (vector<int>::size_type i = 0; i < randomVec->size(); i++)
472             (*randomVec)[i] = rand() % maxValue + 1;
473         return randomVec;
474     }
475 
476     int getSize()
477     {
478         return (int)randomVec->size();
479     }
480 
481 private:
482     int maxValue;
483     int maxSize;
484     vector<int> *randomVec;
485 };
486 
487 int main()
488 {
489     srand((unsigned)time(NULL));
490     RandomArray randomArray(100, 15);
491     vector<int> *randomVec = randomArray.getRandomArray();
492     AVLTree AVLtree;
493     AVLNode *root = (AVLNode *)AVLtree.insert((*randomVec)[0]);
494     cout << "the array for test is : " << (*randomVec)[0] << " ";
495     for (int i = 1; i < randomArray.getSize(); i++)
496     {
497         cout << (*randomVec)[i] << " ";
498         AVLtree.insert((*randomVec)[i]);
499     }
500     cout << endl;
501 
502     AVLtree.printTree();
503 
504     cout << "============================" << endl;
505 
506     int randomIndex = rand() % randomArray.getSize();
507     cout << "the value of delete AVLnode is : " << (*randomVec)[randomIndex] << endl;
508     AVLtree.deleteAVLNode((*randomVec)[randomIndex]);
509     AVLtree.printTree();
510 
511 
512     return 0;
513 }

AVL