转载 AVL(平衡树)C++代码(非递归)

1. #define BALANCE_CHECK
3. #ifndef NULL
4. #define NULL 0
5. #endif
7. /*
8.     Default Value Control
9. */
10. template<typename Type>
11. struct DefaultValue
12. {static Type Value;};
13. template<typename Type>
14. Type DefaultValue<Type>::Value;
16. #define DECLARE_DEFAULT_VALUE(T, value) template<>/
17. struct DefaultValue<T>{static T Value;};/
18. template<>/
19. T DefaultValue<T>::Value = value;
21. DECLARE_DEFAULT_VALUE(int, 0)
22. DECLARE_DEFAULT_VALUE(double, 0)
24. /*
25.     Node
26.         if BALANCE_CHECK is defined, LHeight, RHeight and Height are used;
27. */
28. template<typename Type>
29. struct Node
30. {
31.     Type    Data;
32.     Node*   LChild, *RChild;
33.     int     BalanceFactor;
34.     
35. #ifdef BALANCE_CHECK
36. int     LHeight, RHeight, Height;
37. #endif
38.     
39.     Node(const Type& _Data = DefaultValue<Type>::Value,
40.         Node* _LChild = NULL,
41.         Node* _RChild = NULL,
42.         int   _BalanceFactor = 0):
43.         Data(_Data), 
44.         LChild(_LChild), 
45.         RChild(_RChild),
46.         BalanceFactor(_BalanceFactor)
47.     {}
48. };
50. /*
51.     AVLTree
52.         if BALANCE_CHECK is defined, you can check the balance;
53. */
54. template<typename Type>
55. class AVLTree
56. {
57. public:
58.     
59.         typedef Type              DataType;
60.         typedef Node<Type>        NodeType;
61.         typedef NodeType*         pNodeType;
62.         typedef DefaultValue<Type> DefaultValueType;
63.         
64.         enum {LEFT, RIGHT};
65.         
66. public:
67.     
68.         AVLTree(): head(new NodeType) {}
69.         ~AVLTree() {Destroy();}
70.         
71. public:
72.     
73.         int     Insert(const Type& it);
74.         int     Delete(const Type& it);
75.         int     GetMin(Type& it);
76.         int      GetMax(Type& it);
77. public:
78.         
79.         template<typename OP>
80.         void    PreOrder(OP);
81.         
82.         template<typename OP>
83.         void    InOrder(OP);
84.         
85.     template<typename OP>
86.         void    PreInOrder(int type, OP);
87.         
88. private:
90.         inline  void        ReplaceChild(pNodeType  Parent, pNodeType Child, pNodeType NewChild);
91.         
92.         inline  void        RRotateFactorI(pNodeType Parent, pNodeType Tree);
93.         inline  void        RRotateFactorD(pNodeType Parent, pNodeType Tree);
94.         inline  pNodeType   RRotate(pNodeType Parent, pNodeType Tree);
95.         
96.         inline  void        LRRotateFactorI(pNodeType Parent, pNodeType Tree);
97.         inline  void        LRRotateFactorD(pNodeType Parent, pNodeType Tree);
98.         inline  pNodeType   LRRotate(pNodeType Parent, pNodeType Tree);
99.         
100.         inline  void        LRotateFactorI(pNodeType Parent, pNodeType Tree);
101.         inline  void        LRotateFactorD(pNodeType Parent, pNodeType Tree);
102.         inline  pNodeType   LRotate(pNodeType Parent, pNodeType Tree);
103.         
104.         
105.         inline  void        RLRotateFactorI(pNodeType Parent, pNodeType Tree);
106.         inline  void        RLRotateFactorD(pNodeType Parent, pNodeType Tree);
107.         inline  pNodeType   RLRotate(pNodeType Parent, pNodeType Tree);
108.         
109.         void                Destroy();
110.         void                Destroy(pNodeType Tree);
111. private:
112.         NodeType* head; 
113.         
114.         
115. #ifdef BALANCE_CHECK
116. public:
117.         int     BalanceCheck();
118.         int     BalanceCheck(pNodeType tree);
119. #endif
120. };
122. template<typename Type>
123. int AVLTree<Type>::Insert(const Type& it)
124. {
125.     pNodeType Parent = head, Curr = head->LChild;
126.     pNodeType LastNotBalance = NULL, ParentLastNotBalance = NULL;
127.     
128.     while (Curr)
129.     {
130.         if (Curr->Data == it) return 0;
131.         if (Curr->BalanceFactor) 
132.             ParentLastNotBalance = Parent, LastNotBalance = Curr;
133.         Parent = Curr;
134.         Curr = it < Curr->Data ? Curr->LChild : Curr->RChild;
135.     }
136.     
137.     pNodeType NewNode = new NodeType(it);
138.     
139.     if (Parent == head)
140.     {
141.         head->LChild = NewNode;
142.         return 1;
143.     }
144.     else
145.     {
146.         it < Parent->Data ? 
147.             Parent->LChild = NewNode :
148.             Parent->RChild = NewNode;
149.     }
150.     
151.     for (Curr = LastNotBalance ? LastNotBalance : head->LChild;
152.         Curr != NewNode;)
153.     {
154.         it < Curr->Data ?
155.             (++Curr->BalanceFactor, Curr = Curr->LChild):
156.             (--Curr->BalanceFactor, Curr = Curr->RChild);
157.     }
158.     
159.     if (!LastNotBalance || LastNotBalance->BalanceFactor < 2 &
160.             LastNotBalance->BalanceFactor > -2)
161.         return 1;
162.     
163.     if (it < LastNotBalance->Data)
164.     {
165.         if (it < LastNotBalance->LChild->Data )
166.         {
167.             RRotateFactorI(ParentLastNotBalance, LastNotBalance);
168.             ReplaceChild(
169.                         ParentLastNotBalance, 
170.                         LastNotBalance,
171.                         RRotate(ParentLastNotBalance, LastNotBalance)
172.                         );
173.         }
174.         else
175.         {
176.             LRRotateFactorI(ParentLastNotBalance, LastNotBalance);      
177.             ReplaceChild(
178.                         ParentLastNotBalance, 
179.                         LastNotBalance,
180.                         LRRotate(ParentLastNotBalance, LastNotBalance)
181.                         );
182.         }
183.     }
184.     else
185.     {
186.         if (it > LastNotBalance->RChild->Data)
187.         {
188.             LRotateFactorI(ParentLastNotBalance, LastNotBalance);
189.             ReplaceChild(
190.                         ParentLastNotBalance, 
191.                         LastNotBalance,
192.                         LRotate(ParentLastNotBalance, LastNotBalance)
193.                         );
194.         }
195.         else
196.         {
197.             
198.             RLRotateFactorI(ParentLastNotBalance, LastNotBalance);
199.             ReplaceChild(
200.                         ParentLastNotBalance, 
201.                         LastNotBalance,
202.                         RLRotate(ParentLastNotBalance, LastNotBalance)
203.                         );
204.         }
205.     }
206.     return 1;
207. }
209. template<typename Type>
210. int AVLTree<Type>::Delete(const Type& it)
211. {
212.     pNodeType SearchHistory[64];
213.     int       SearchDirection[64];
214.     int       CurrIdx;
215.     
216.     pNodeType Curr = head->LChild;
217.     SearchHistory[0] = head;
218.     SearchDirection[0] = 0;
219.     CurrIdx = 1;
220.     
221.     while (Curr && Curr->Data != it)
222.     {
223.         SearchHistory[CurrIdx] = Curr;
224.         it < Curr->Data ?
225.             (Curr = Curr->LChild, SearchDirection[CurrIdx] = LEFT): 
226.             (Curr = Curr->RChild, SearchDirection[CurrIdx] = RIGHT);
227.         ++CurrIdx;
228.     }
229.     
230.     if (!Curr) return 0;
231.     
232.     pNodeType ToBeDeleted = Curr;
233.     if (Curr->LChild && Curr->RChild)
234.     {
235.         pNodeType  CurrT = Curr->LChild;
236.         SearchHistory[CurrIdx] = Curr;
237.         SearchDirection[CurrIdx++] = LEFT;
238.         while (CurrT->RChild)
239.         {
240.             SearchHistory[CurrIdx] = CurrT;
241.             SearchDirection[CurrIdx++] = RIGHT;
242.             CurrT = CurrT->RChild;
243.         }
244.         Curr->Data = CurrT->Data;
245.         ToBeDeleted = CurrT;
246.     }
247.     
248.     
249.     // There exists at least one child that is NULL
250.     {
251.         pNodeType Temp = 
252.             ToBeDeleted->LChild ?
253.                 ToBeDeleted->LChild :
254.                     (ToBeDeleted->RChild  ? ToBeDeleted->RChild : NULL);
255.         delete ToBeDeleted;
256.         --CurrIdx;//    Indidate the pointer to the parent of the node to be deleted
257.         SearchDirection[CurrIdx] == RIGHT ?
258.             SearchHistory[CurrIdx]->RChild = Temp:
259.             SearchHistory[CurrIdx]->LChild = Temp;
260.     }
262.     for (int HeightChanged = 1; HeightChanged && CurrIdx; --CurrIdx)
263.     {   
264.         pNodeType ToBeAdjusted = SearchHistory[CurrIdx];
265.         pNodeType ParentToBeAdjusted = SearchHistory[CurrIdx-1];
266.         int       ChangedChild = SearchDirection[CurrIdx];
267.         if (ToBeAdjusted->BalanceFactor == 0)
268.         {
269.             ToBeAdjusted->BalanceFactor = ChangedChild == LEFT? -1 : 1;
270.             HeightChanged = 0;
271.         }
272.         else if (ToBeAdjusted->BalanceFactor == -1)
273.         {
274.             if (ChangedChild == RIGHT)
275.             {
276.                 ToBeAdjusted->BalanceFactor = 0;
277.                 HeightChanged = 1;
278.             }
279.             else
280.             {
281.                 switch (ToBeAdjusted->RChild->BalanceFactor)
282.                 {
283.                 case 0:
284.                     HeightChanged = 0;
285.                     LRotateFactorD(ParentToBeAdjusted, ToBeAdjusted);
286.                     ReplaceChild(ParentToBeAdjusted, ToBeAdjusted,
287.                                 LRotate(ParentToBeAdjusted, ToBeAdjusted));
288.                     break;
289.                 case -1:
290.                     HeightChanged = 1;
291.                     LRotateFactorD(ParentToBeAdjusted, ToBeAdjusted);
292.                     ReplaceChild(ParentToBeAdjusted, ToBeAdjusted,
293.                                 LRotate(ParentToBeAdjusted, ToBeAdjusted));
294.                     break;
295.                 case 1:
296.                     HeightChanged = 1;
297.                     RLRotateFactorD(ParentToBeAdjusted, ToBeAdjusted);
298.                     ReplaceChild(ParentToBeAdjusted, ToBeAdjusted,
299.                                 RLRotate(ParentToBeAdjusted, ToBeAdjusted));
300.                 }
301.             }
302.         }
303.         else
304.         {
305.             if (ChangedChild == LEFT)
306.             {
307.                 ToBeAdjusted->BalanceFactor = 0;
308.                 HeightChanged = 1;
309.             }
310.             else
311.             {
312.                 switch (ToBeAdjusted->LChild->BalanceFactor)
313.                 {
314.                 case 0:
315.                     HeightChanged = 0;
316.                     RRotateFactorD(ParentToBeAdjusted, ToBeAdjusted);
317.                     ReplaceChild(ParentToBeAdjusted, ToBeAdjusted,
318.                                 RRotate(ParentToBeAdjusted, ToBeAdjusted));
319.                     break;
320.                 case 1:
321.                     HeightChanged = 1;
322.                     RRotateFactorD(ParentToBeAdjusted, ToBeAdjusted);
323.                     ReplaceChild(ParentToBeAdjusted, ToBeAdjusted,
324.                                 RRotate(ParentToBeAdjusted, ToBeAdjusted));
325.                     break;
326.                 case -1:
327.                     HeightChanged = 1;
328.                     LRRotateFactorD(ParentToBeAdjusted, ToBeAdjusted);
329.                     ReplaceChild(ParentToBeAdjusted, ToBeAdjusted,
330.                                 LRRotate(ParentToBeAdjusted, ToBeAdjusted));
331.                 }
332.             }
333.         }       
334.     }
335.     
336.     return 1;
337. }
339. template<typename Type>
340. int     AVLTree<Type>::GetMin(Type& it)
341. {
342.     pNodeType   Curr = head->LChild;
343.     if (!Curr) return 0;
344.     while (Curr->LChild) Curr = Curr->LChild;
345.     it = Curr->Data;
346.     return 1;
347. }   
349. template<typename Type>
350. int     AVLTree<Type>::GetMax(Type& it)
351. {
352.     pNodeType   Curr = head->LChild;
353.     if (!Curr) return 0;
354.     while (Curr->RChild) Curr = Curr->RChild;
355.     it = Curr->Data;
356.     return 1;
357. }    
359. template<typename Type>
360. template<typename OP>
361. void AVLTree<Type>::PreOrder(OP ope)
362. {
363.     PreInOrder(0, ope);
364. }
366. template<typename Type>
367. template<typename OP>
368. void AVLTree<Type>::InOrder(OP ope)
369. {
370.     PreInOrder(1, ope);
371. }
373. template<typename Type>
374. template<typename OP>
375. void AVLTree<Type>::PreInOrder(int type, OP ope)
376. {
377.     pNodeType Curr = head->LChild;
378.     pNodeType R = NULL;
379.     
380.     while (true)
381.     {
382.         if (Curr == NULL) break;
383.         
384.         pNodeType q = Curr->LChild;
385.         if (q == NULL)
386.         {
387.             ope(Curr->Data);
388.             R = Curr;
389.             Curr = Curr->RChild;
390.         }
391.         else
392.         {
393.             while (q->RChild != NULL && q->RChild != Curr)
394.                 q = q->RChild;
395.             if (q->RChild == NULL)
396.             {
397.                 q->RChild = Curr;
398.                 if (type == 0) ope(Curr->Data);;
399.                 Curr = Curr->LChild;
400.             }
401.             else
402.             {   
403.                 R = Curr;
404.                 if (type == 1) ope(Curr->Data);
405.                 Curr = Curr->RChild;
406.                 q->RChild = NULL;
407.             }
408.             
409.         }
410.     }
411. }
413. template<typename Type>
414. inline  void        
415. AVLTree<Type>::ReplaceChild(pNodeType  Parent, pNodeType Child, pNodeType NewChild)
416. {
417.     Parent->LChild == Child ?
418.         Parent->LChild = NewChild :
419.         Parent->RChild = NewChild ;
420. }
422. // Right rotate the tree
423. template<typename Type>
424. inline void 
425. AVLTree<Type>::RRotateFactorI(pNodeType Parent, pNodeType Tree)
426. {
427.     Tree->BalanceFactor = 0;
428.     Tree->LChild->BalanceFactor = 0;
429. }
431. template<typename Type>
432. inline void
433. AVLTree<Type>::RRotateFactorD(pNodeType Parent, pNodeType Tree)
434. {
435.     pNodeType A = Tree;
436.     pNodeType B = Tree->LChild;
437.     if (B->BalanceFactor == 0)
438.     {
439.         A->BalanceFactor = 1;
440.         B->BalanceFactor = -1;
441.     }
442.     else
443.     {
444.         A->BalanceFactor = 0;
445.         B->BalanceFactor = 0;
446.     }
447. }
449. template<typename Type>
450. inline typename AVLTree<Type>::pNodeType 
451. AVLTree<Type>::RRotate(pNodeType Parent, pNodeType Tree)
452. {
453.     pNodeType A = Tree;
454.     pNodeType B = Tree->LChild;
455.     A->LChild = B->RChild;
456.     B->RChild = A;
457.     return B;
458. }
460. // Left rotate the LChild of the tree and right rotate the tree
461. template<typename Type>
462. inline void
463. AVLTree<Type>::LRRotateFactorI(pNodeType Parent, pNodeType Tree)
464. {
465.     pNodeType A = Tree;
466.     pNodeType B = Tree->LChild;
467.     pNodeType C = B->RChild;
468.     
469.     switch (C->BalanceFactor)
470.     {
471.     case  1:
472.                 B->BalanceFactor = 0;
473.                 A->BalanceFactor = -1;
474.                 C->BalanceFactor = 0;
475.                 break;
476.     case -1:
477.                 B->BalanceFactor = 1;
478.                 A->BalanceFactor = 0;
479.                 C->BalanceFactor = 0;
480.                 break;
481.     case 0:
482.                 B->BalanceFactor = 0;
483.                 A->BalanceFactor = 0;
484.                 C->BalanceFactor = 0;
485.     }
486. }
488. template<typename Type>
489. inline void
490. AVLTree<Type>::LRRotateFactorD(pNodeType Parent, pNodeType Tree)
491. {
492.     pNodeType A = Tree;
493.     pNodeType B = Tree->LChild;
494.     pNodeType C = B->RChild;
495.     
496.     switch (C->BalanceFactor)
497.     {
498.     case  -1:
499.                 A->BalanceFactor = 0;
500.                 B->BalanceFactor = 1;
501.                 C->BalanceFactor = 0;
502.                 break;
503.     case 0:
504.                 A->BalanceFactor = 0;
505.                 B->BalanceFactor = 0;
506.                 C->BalanceFactor = 0;
507.                 break;
508.     case 1:
509.                 A->BalanceFactor = -1;
510.                 B->BalanceFactor = 0;
511.                 C->BalanceFactor = 0;
512.     }
513. }
515. template<typename Type>
516. inline typename AVLTree<Type>::pNodeType
517. AVLTree<Type>::LRRotate(pNodeType Parent, pNodeType Tree)
518. {
519.     pNodeType A = Tree;
520.     pNodeType B = Tree->LChild;
521.     pNodeType C = B->RChild;
522.     
523.     B->RChild = C->LChild;
524.     A->LChild = C->RChild;
525.     C->LChild = B;
526.     C->RChild = A;
527.                 
528.     return C;
529. }
531. // Left rotate the tree
532. template<typename Type>
533. inline void
534. AVLTree<Type>::LRotateFactorI(pNodeType Parent, pNodeType Tree)
535. {
536.     Tree->BalanceFactor = 0;
537.     Tree->RChild->BalanceFactor = 0;
538. }
540. template<typename Type>
541. inline void
542. AVLTree<Type>::LRotateFactorD(pNodeType Parent, pNodeType Tree)
543. {
544.     pNodeType A = Tree;
545.     pNodeType B = Tree->RChild;
546.     if (B->BalanceFactor == 0)
547.     {
548.         A->BalanceFactor = -1;
549.         B->BalanceFactor = 1;
550.     }
551.     else
552.     {
553.         A->BalanceFactor = 0;
554.         B->BalanceFactor = 0;
555.     }
556. }
558. template<typename Type>
559. inline typename AVLTree<Type>::pNodeType
560. AVLTree<Type>::LRotate(pNodeType Parent, pNodeType Tree)
561. {
562.     pNodeType A = Tree;
563.     pNodeType B = Tree->RChild;
564.     
565.     A->RChild = B->LChild;
566.     B->LChild = A;
567.     
568.     return B;
569. }
571. // Right rotate the RChild of the tree and left rotate the tree
572. template<typename Type>
573. inline void
574. AVLTree<Type>::RLRotateFactorI(pNodeType Parent, pNodeType Tree)
575. {
576.     pNodeType A = Tree;
577.     pNodeType B = Tree->RChild;
578.     pNodeType C = B->LChild;
579.     
580.     switch (C->BalanceFactor)
581.     {
582.     case  1:
583.             B->BalanceFactor = -1;
584.             A->BalanceFactor = 0;
585.             C->BalanceFactor = 0;
586.             break;
587.     case -1:
588.             B->BalanceFactor = 0;
589.             A->BalanceFactor = 1;
590.             C->BalanceFactor = 0;
591.             break;
592.     case 0:
593.             B->BalanceFactor = 0;
594.             A->BalanceFactor = 0;
595.             C->BalanceFactor = 0;
596.     }
597. }
599. template<typename Type>
600. inline void
601. AVLTree<Type>::RLRotateFactorD(pNodeType Parent, pNodeType Tree)
602. {
603.     
604.     pNodeType A = Tree;
605.     pNodeType B = Tree->RChild;
606.     pNodeType C = B->LChild;
607.     
608.     switch (C->BalanceFactor)
609.     {
610.     case  -1:
611.                 A->BalanceFactor = 1;
612.                 B->BalanceFactor = 0;
613.                 C->BalanceFactor = 0;
614.                 break;
615.     case 0:
616.                 A->BalanceFactor = 0;
617.                 B->BalanceFactor = 0;
618.                 C->BalanceFactor = 0;
619.                 break;
620.     case 1:
621.                 A->BalanceFactor = 0;
622.                 B->BalanceFactor = -1;
623.                 C->BalanceFactor = 0;
624.     }
625. }
627. template<typename Type>
628. inline typename AVLTree<Type>::pNodeType
629. AVLTree<Type>::RLRotate(pNodeType Parent, pNodeType Tree)
630. {
631.     pNodeType A = Tree;
632.     pNodeType B = Tree->RChild;
633.     pNodeType C = B->LChild;
634.             
635.     B->LChild = C->RChild;
636.     A->RChild = C->LChild;
637.     C->LChild = A;
638.     C->RChild = B;
639.             
640.     return C;
641. }
643. template<typename Type>
644. void    AVLTree<Type>::Destroy()
645. {
646.     if (head) Destroy(head->LChild);
647.     head = NULL;
648. }    
650. template<typename Type>
651. void    AVLTree<Type>::Destroy(pNodeType Tree)
652. {
653.     if (!Tree) return;
654.     Destroy(Tree->LChild);
655.     Destroy(Tree->RChild);
656.     delete Tree;
657. }
659. #ifdef BALANCE_CHECK
660. template<typename Type>
661. int AVLTree<Type>::BalanceCheck()
662. {
663.     return BalanceCheck(head->LChild);
664. }
666. template<typename Type>
667. int AVLTree<Type>::BalanceCheck(pNodeType tree)
668. {
669.     int LBalance = 1, RBalance = 1;
670.     if (tree->LChild)
671.     {   
672.         LBalance = BalanceCheck(tree->LChild);
673.         tree->LHeight = tree->LChild->Height;
674.     }
675.     else
676.     {
677.         tree->LHeight = 0;
678.     }
679.     if (tree->RChild)
680.     {   
681.         RBalance = BalanceCheck(tree->RChild);
682.         tree->RHeight = tree->RChild->Height;
683.     }
684.     else
685.     {
686.         tree->RHeight = 0;
687.     }
688.     
689.     tree->Height = max(tree->LHeight, tree->RHeight) + 1;
690.     return LBalance && RBalance &
691.         tree->BalanceFactor == tree->LHeight - tree->RHeight;
692. }
693. #endif
695. #include <iostream>
696. #include <cstdlib>
697. #include <ctime>
698. using namespace std;
700. template<typename T>
701. void visit(T i)
702. {cout << i << " ";}    
704. int main()
705. {
706.     AVLTree<int> it;
707.     int m;
708.     
709.     it.Insert(1);
710.     for (int i = 0; i < 24; ++i)
711.         it.Insert(rand());
712.     it.InOrder(visit<int>);
713.     it.GetMax(m);
714.     cout << endl << m << endl;
715.     it.GetMin(m);
716.     cout << m << endl;
718.     system("pause");
719.     return 0;
720. }
721. 转自 http://blog.csdn.net/baihacker/archive/2008/08/20/2803362.aspx