Алгоритмы сортировки. Время выполнения

#include <iostream>
#include <windows.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
void heapify(int *A, int i);
void heapsort(int *A);
void build_heap (int *A);
int Left(int i);
int Right(int i);
void input(int *A, int n);
//////////////////////////////////
int Partition (int* A, int p, int r);
void QuickSort(int* A, int p, int r);
/////////////////////////////////
void insertion_sort(int* A, int n);
////////////////////////////////
void merge_sort(int *A, int p, int r);
void merge (int *A, int p, int q, int r);
int n=1000,r=n-1,p=0,heap_size;
int main()
{
    
    srand((unsigned)time(NULL));
    int* A=new int[n];
    input(A,n);
    int t;
 
    t=GetTickCount();
    heapsort(A);
    cout<<GetTickCount()-t<<"ms"<<endl;
 
    t=GetTickCount();
    insertion_sort(A, n);
    cout<<GetTickCount()-t<<"ms"<<endl;
 
    t=GetTickCount();
    merge_sort(A, p, r);
    cout<<GetTickCount()-t<<"ms"<<endl;
 
    t=GetTickCount();
    QuickSort(A,p,r);
    cout<<GetTickCount()-t<<"ms"<<endl;
 
    system("pause");
    return 0;
}
int Left(int i)
{
    return 2*i;
}
int Right(int i)
{
    return 2*i+1;
}
void heapify(int *A, int i)
{
    int l=Left(i),r=Right(i), largest;
    if(l<heap_size && A[l]>A[i])
        largest=l;
    else
        largest=i;
    if(r<heap_size && A[r]>A[largest])
        largest=r;
    if(largest!=i)
    {
        swap(A[i],A[largest]);
        heapify(A, largest);
    }
    
}
void build_heap (int *A)
{
    heap_size=n;
    for(int i=n/2; i>=0; i--)
        heapify(A, i);
}
void heapsort(int *A)
{
    build_heap (A);
    for(int i=n-1;i>=1; i--)
    {
        swap(A[0],A[i]);
        heap_size=heap_size-1;
        heapify(A, 0);
    }
}
void input(int *A, int n)
{
    for(int i=0;i<=n;i++)
    {
        int A=rand()%1000;
    }
}
int Partition (int* A, int p, int r)
{
    int x=A[r];
    int i=p-1;
    for (int j=p; j<r; j++)
    {
        if (A[j]<=x) 
        {
            i=i+1;
            swap(A[i],A[j]);
        }
        
        
    }
    swap(A[i+1],A[r]);
    return i+1;
        
}
void QuickSort(int* A, int p, int r)
{
    int q=0;
    if (p<r)
    {
        q=Partition ( A, p,  r);
        QuickSort(A, p, q-1);
        QuickSort(A, q+1, r);
    }
}
void insertion_sort(int* A, int n)
{
    int key,i;
    for(int j=1;j<n;j++)
    {
        key=A[j];
        i=j-1;
        while(i>0 && A[i]>key)
        {
            A[i+1]=A[i];
            i=i-1;
        }
        A[i+1]=key;
            
    }
 
}
void merge_sort(int *A, int p, int r)
{ 
    if(p<r) 
    { 
    int q=(p+r)/2;
    merge_sort(A, p, q);
    merge_sort(A, q+1, r);
    merge(A, p, q, r); 
    } 
} 
void merge (int *A, int p, int q, int r) 
{
    int i=p, j=q+1, k=0, l;
    int* c=new int[r-p+1]; 
    while(i<=q && j<=r)
    { 
        if(A[i]<A[j]) 
    { 
        A[k]=A[i]; 
        i++; 
    }
        else 
    { 
        c[k]=A[j]; 
        j++; 
    }
        k++; 
    } 
        if(i<=q) 
            l=i; 
        else 
            l=j; 
            while(k<=r-p) 
            { 
                c[k]=A[l]; 
                k++; 
                l++; 
            } 
    for(int l=0; l<k; l++) 
    A[l+p]=c[l];
}