【排序算法】-堆排序

只实现了最大堆，最小堆同理；没有设置模板接口创建最小堆，之后改进。环境：VS2010 C++ Win10 64位。

template <typename Type>
class Heap
{
public:
    void sort(vector <Type> &array);
    void buildHeap(vector <Type>&array);
    Heap() :heapSize(0){}
private:
    int heapSize;
    void keepHeap(vector <Type>& array, int element);
    int left(int element){ return element * 2+1; }
    int right(int element){ return (element+1) * 2 ; }
    void  swap(vector <Type>& array, int n1, int n2);
};
template<typename Type>
void  Heap<Type> ::keepHeap(vector <Type>& array, int element)
{//维护最大堆性质
    int l = left(element), r = right(element);
    int largest = 0;
    if (l < heapSize && array.at(l) > array.at(element))
        largest = l;
    else
        largest = element;
    if (r < heapSize && array.at(r) > array.at(largest))
        largest = r;

    if (largest != element)
    {
        swap(array, element, largest);
        keepHeap(array, largest);
    }
}

template<typename Type>
void Heap<Type>::buildHeap(vector <Type>&array)
{
    heapSize = array.size();
    for (int i = array.size() / 2-1 ; i >= 0 ; --i)
    {
        keepHeap(array, i);
    }
}
template<typename Type>
void Heap<Type> ::sort(vector <Type>&array)
{
    buildHeap(array);
    for (int i = array.size() - 1; i >0; --i)
    {
        swap(array, 0, i);
        heapSize--;
        keepHeap(array, 0);
    }
}
template<typename Type>
void Heap<Type>::swap(vector <Type>& array, int n1, int n2)
{
    Type tmp = array[n1];
    array[n1] = array[n2];
    array[n2] = tmp;
}

算法特点归纳总结：
算法实现较为复杂，维护堆性质部分，使用了递归的算法，程序开销较大。算法平均复杂度和最坏情况为$O（nlog(n)）$，最好情况为$O（n）$，属于In-place 操作。空间开销不大。算法稳定。但是由于维护堆函数复杂，实际使用中时间开销并不理想。