implement a AVL tree use c++ (Non_Recursive),write by baihacker

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