堆排序

#include <iostream>

using namespace std;

#define ARR_SIZE 20

void CreateRandArr(int a[]);

template <typename T>
class MaxPQ
{
    private:
        int *ar = NULL;
        int N = ARR_SIZE;

    public:
        MaxPQ();
        MaxPQ(T ap[], int size);
        MaxPQ(const MaxPQ & ap);   //注意这里必须是引用
        bool isEmpty(){return 0 == N;}
        int size(void){return N;}
        void insert(T v);
        T delMax(void);
        void sink(int n, int size);
        void swim(int n);
        void sort(void);
        void exch(int m, int n){T temp = ar[m];ar[m] = ar[n]; ar[n] = temp;}
        void show(void);
        MaxPQ<T> & operator=(const MaxPQ<T> & ap);
        ~MaxPQ(){delete [] ar;}
};

template <typename T>
MaxPQ<T>::MaxPQ()
{
    ar = (int *)new int [ARR_SIZE + 1];
    CreateRandArr(ar+1);
}

template <typename T>
MaxPQ<T>::MaxPQ(T ap[], int size)
{
    N = size; 
    ar = (T *)new T [N + 1]; 
    for(int i = 1; i <= N; i++)
    {
        ar[i] = ap[i-1];
    }
}

template <typename T>
MaxPQ<T>::MaxPQ(const MaxPQ & ap)
{
    if(ap == *this)
        return;
    else
    {
        N = ap.size();
        ar = new T [N+1];
        for(int i=1;i<N;i++)
        {
            ar[i] = ap.ar[i];
        }
    }
}

template <typename T>
MaxPQ<T> & MaxPQ<T>::operator=(const MaxPQ<T> & ap)
{
    if(ap == *this)
        return this;
    else
    {
        delete [] ar;
        N = ap.N;
        ar = new T [N+1];
        for(int i=1;i<N;i++)
        {
            ar[i] = ap.ar[i];
        }
    }

    return *this;
}

template <typename T>
void MaxPQ<T>::insert(T v)
{
    ar[++N] = v; 
    swim(N);
}

template <typename T>
T MaxPQ<T>::delMax(void)
{
    T max = ar[1];
    ar[1] = ar[N];
    /* ar[N] = NULL; */
    sink(1, N);
    return max;
}

template <typename T>
void MaxPQ<T>::sink(int n, int size)
{
    while(2 * n <= size)
    {
        int j = 2 * n;
        if(j < size && ar[j] < ar[j+1]) j++;   // ar[2n] 和 ar[2n+1] 取较大者
        if(ar[n] >= ar[j]) break;
        exch(n, j);
        n = j;
    }
}

template <typename T>
void MaxPQ<T>::swim(int n)
{
    while(n > 1 && ar[n/2] < ar[n])
    {
        exch(n/2, n);
        n = n/2;
    }
}

template <typename T>
void MaxPQ<T>::sort(void)
{
    for(int k = N/2; k >=1; k--)
        sink(k, N);     // 先对数组进行堆有序处理
    int num = N;
    while(num > 1)
    {
        exch(1, num--);   // 将最大元素放到当前堆的最后一个位置
        sink(1, num);  // 利用下沉保持堆有序
    }
}

template <typename T>
void MaxPQ<T>::show(void)
{
    for(int i=1; i<=N; i++)
    {
        cout << ar[i] << ' ';
    }
    cout << endl;
}


void CreateRandArr(int a[])
{
    int i;
    for(i=0;i<ARR_SIZE;i++)
    {
        a[i] = rand() % 100;
        cout <<a[i] << ' ' ; 
    }
    cout << endl;
}

int main()
{
    int ar[ARR_SIZE];
    CreateRandArr(ar);
    MaxPQ<int> arr(ar, ARR_SIZE);    // 也可以用默认初始化
    arr.sort();
    cout << "after sort: " << endl;
    arr.show();
    
    return 0;
}

上面的sink函数是否应该替换成下面这种形式？（因为j+1有可能大于size而造成越界）

void sink(int a[], int k, int n)
{
    int temp;
    while(2*k <= n)
    {
        if(2*k+1 <= n && a[2*k+1] > a[2*k])
        temp = 2*k+1;
        else temp = 2*k;
        if(a[temp] > a[k]) exchange(a, temp, k);
        else break;
        k = temp;
    }
}