[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 = 0;
}

template<typename T> inline int Heap<T>::parent(int idx) {
    return (idx - 1) >> 1;
}

template<typename T> inline int Heap<T>::left(int idx) {
    return (idx << 1) + 1;
}

template<typename T> inline int Heap<T>::right(int idx) {
    return (idx << 1) + 2;
}

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) - 1; i >= 0; i--)
        max_heapify(i);
}

template<typename T> void Heap<T>::heap_sort(void) {
    int size = heap_size - 1;
    for (int i = size; i > 0; i--) {
        swap(data[i], data[0]);
        heap_size--;
        max_heapify(0);
    }
}

template<typename T> T Heap<T>::maximum(void) {
    return data[0];
}

template<typename T> T Heap<T>::extract_max(void) {
    if (data.empty()) throw runtime_error("Heap underflow!");
    int maximum = data[0];
    swap(data[0], data[heap_size - 1]);
    heap_size--;
    max_heapify(0);
    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 - 1);
    heap_size++;
    increase_key(heap_size - 1, key);
}

template<typename T> void Heap<T>::print(void) {
    printf("In heap: ");
    for (int i = 0; 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("
");
}

void heap_test(void) {
    int num[] = {4, 1, 3, 2, 16, 9, 10, 14, 8, 7};
    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
", heap.maximum());
    printf("%d
", heap.extract_max());
    heap.print();
    // Test increase_key()
    heap.increase_key(3, 5);
    heap.print();
    // Test insert_key()
    heap.insert_key(20);
    heap.print();
    // Test heap_sort()
    heap.heap_sort();
    heap.print();
}

int main(void) {
    heap_test();
    system("pause");
    return 0;
}

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

In heap: 16 14 10 8 7 9 3 2 4 1 ,
16
16
In heap: 14 8 10 4 7 9 3 2 1 , Out of heap: 16
In heap: 14 8 10 5 7 9 3 2 1 , Out of heap: 16
In heap: 20 14 10 5 8 9 3 2 1 7 , Out of heap: 16
In heap: 1 , Out of heap: 2 3 5 7 8 9 10 14 20 16

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