最大堆与堆排序

参考《Introduce to Algorithm》

  1 #ifndef MAX_HEAP_H
  2 #define MAX_HEAP_H
  3
  4 const int MAX_SIZE = 100 + 1 ;
  5
  6 template < typename Type >
  7 class MaxHeap
  8 {
  9     public :
10         MaxHeap();
11         MaxHeap(Type * arr, int size);
12         // ~MaxHeap();
13        
14         void travel();
15         void HeapSort();
16
17     private :
18         Type _arr[MAX_SIZE];
19         int _size;
20
21         void MaxHeapify( int startIndex); // 调整堆
22         void InitBuildMaxHeap(); // 初始建堆
23         void swap(Type & a, Type & b);
24 };
25
26 template < typename Type >
27 MaxHeap < Type > ::MaxHeap()
28 {
29     for ( int i = 0 ; i < MAX_SIZE; i ++ )
30     {
31         _arr[i] = 0 ;
32     }
33     _size = 0 ;
34 }
35
36 template < typename Type >
37 MaxHeap < Type > ::MaxHeap(Type * arr, int size)
38 {
39     if (size > MAX_SIZE)
40     {
41         cerr << " larger than MAX_SIZE " << endl;
42     }
43     for ( int i = 0 ; i < size; i ++ )
44     {
45         _arr[i + 1 ] = arr[i];
46     }
47     _size = size;
48     InitBuildMaxHeap();
49 }
50
51 template < typename Type >
52 void MaxHeap < Type > ::HeapSort()
53 {
54     int tmp = _size;
55     for ( int i = _size; i >= 2 ; i -- )
56     {
57         swap(_arr[ 1 ], _arr[i]);
58         _size -- ;
59         MaxHeapify( 1 );
60     }
61    
62     _size = tmp;
63    
64 }
65
66 template < typename Type >
67 void MaxHeap < Type > ::InitBuildMaxHeap()
68 {
69     for ( int i = _size / 2 ; i >= 1 ; i -- )
70     {
71         MaxHeapify(i);
72     }
73 }
74
75
76
77 template < typename Type >
78 void MaxHeap < Type > ::travel()
79 {   
80     for ( int i = 1 ; i <= _size; i ++ )
81         cout << _arr[i] << " " ;
82
83     cout << endl;
84 }
85
86
87 template < typename Type >
88 void MaxHeap < Type > ::MaxHeapify( int startIndex)
89 {
90     int maxIndex = startIndex;
91     if ( 2 * startIndex <= _size && _arr[startIndex] < _arr[ 2 * startIndex])
92         maxIndex = 2 * startIndex;
93     if ( 2 * startIndex + 1 <= _size && _arr[maxIndex] < _arr[ 2 * startIndex + 1 ])
94         maxIndex = 2 * startIndex + 1 ;
95
96     if (maxIndex != startIndex)
97     {
98         swap(_arr[startIndex], _arr[maxIndex]);
99         MaxHeapify(maxIndex);
100     }
101
102 }
103
104
105 template < typename Type >
106 void MaxHeap < Type > ::swap(Type & a, Type & b)
107 {
108     Type t;
109     t = a;
110     a = b;
111     b = t;
112 }
113
114
115
116
117 #endif

1 #include < iostream >
2 #include " maxHeap.h "
3 using namespace std;
4
5 int main()
6 {
7     int arr[ 9 ] = { 23 , 43 , 74 , 12 , 4 , 69 , 28 , 26 , 32 };
8     MaxHeap < int > obj(arr, 9 );
9     obj.travel();
10     obj.HeapSort();
11     obj.travel();
12
13     return 0 ;
14 }

分类: Data Structure