[Algorithms] Heap and Heapsort

Recently I reviewed the classic heapsort algorithm and implement it according to contents in Introduction to Algorithms (3rd edition). The heap data structure is implemented as a template class and the heapsort algorithm is implemented as a public method of the template class. The code is as follows.

 #include <iostream>
 #include <vector>
 
 using namespace std;
 
 template<typename T> class Heap {
 public:
     Heap(vector<T>&);
     ~Heap(void);
 
     inline int parent(int);
     inline int left(int);
     inline int right(int);
 
     void max_heapify(int);
     void build_max_heap(void);
     void heap_sort(void);
 
     /* Methods for maximum priority queue. */
     T maximum(void);
     T extract_max(void);
     void increase_key(int, T);
     void insert_key(T);
 
     void print(void);
 private:
     vector<T> data;
     int heap_size;
 };
 
 template<typename T> Heap<T>::Heap(vector<T>& d) {
     data = d;
     build_max_heap();
 }
 
 template<typename T> Heap<T>::~Heap(void) {
     data.clear();
     heap_size = ;
 }
 
 template<typename T> inline int Heap<T>::parent(int idx) {
     return (idx - ) >> ;
 }
 
 template<typename T> inline int Heap<T>::left(int idx) {
     return (idx << ) + ;
 }
 
 template<typename T> inline int Heap<T>::right(int idx) {
     return (idx << ) + ;
 }
 
 template<typename T> void Heap<T>::max_heapify(int idx) {
     int largest = idx;
     int l = left(idx);
     int r = right(idx);
     if (l < heap_size && data[l] > data[largest]) largest = l;
     if (r < heap_size && data[r] > data[largest]) largest = r;
     if (largest != idx) {
         swap(data[idx], data[largest]);
         max_heapify(largest);
     }
 }
 
 template<typename T> void Heap<T>::build_max_heap(void) {
     heap_size = data.size();
     for (int i = (heap_size >> 1) - ; i >= ; i--)
         max_heapify(i);
 }
 
 template<typename T> void Heap<T>::heap_sort(void) {
     int size = heap_size - ;
     for (int i = size; i > ; i--) {
         swap(data[i], data[]);
         heap_size--;
         max_heapify();
     }
 }
 
 template<typename T> T Heap<T>::maximum(void) {
     return data[];
 }
 
 template<typename T> T Heap<T>::extract_max(void) {
     if (data.empty()) throw runtime_error("Heap underflow!");
     int maximum = data[];
     swap(data[], data[heap_size - ]);
     heap_size--;
     max_heapify();
     return maximum;
 }
 
 template<typename T> void Heap<T>::increase_key(int idx, T key) {
     if (key < data[idx]) {
         cerr << "New key is smaller!" << endl;
         return;
     }
     data[idx] = key;
     while (idx >= 0 && parent(idx) >= 0 && data[parent(idx)] < data[idx]) {
         swap(data[idx], data[parent(idx)]);
         idx = parent(idx);
     }
 }
 
 template<typename T> void Heap<T>::insert_key(T key) {
     data.insert(data.begin() + heap_size, key - );
     heap_size++;
     increase_key(heap_size - , key);
 }
 
 template<typename T> void Heap<T>::print(void) {
     printf("In heap: ");
     for (int i = ; i < heap_size; i++)
         printf("%d ", data[i]);
     printf(", ");
     if (heap_size < (int)data.size()) {
         printf("Out of heap: ");
         for (int i = heap_size; i < (int)data.size(); i++)
             printf("%d ", data[i]);
     }
     printf("\n");
 }
 
 void heap_test(void) {
     int num[] = {, , , , , , , , , };
     vector<int> nums(num, num + sizeof(num) / sizeof(int));
     // Construct a heap and print it
     Heap<int> heap(nums);
     heap.print();
     // Test maximum() and extract_max()
     printf("%d\n", heap.maximum());
     printf("%d\n", heap.extract_max());
     heap.print();
     // Test increase_key()
     heap.increase_key(, );
     heap.print();
     // Test insert_key()
     heap.insert_key();
     heap.print();
     // Test heap_sort()
     heap.heap_sort();
     heap.print();
 }
 
 int main(void) {
     heap_test();
     system("pause");
     return ;
 }

If you run this code, the expected output is  like (I am testing it in Microsoft Visual Studio Professional 2012):

In heap:           ,
 
In heap:          , Out of heap:
In heap:          , Out of heap:
In heap:           , Out of heap:
In heap:  , Out of heap:          

Welcome for any question, comment and suggestion about the code!