最大堆与堆排序

参考《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 }