Heapsort比插入排序更糟糕

Question

我已实现了heapsort和插入排序，并测量了每种算法的时间。我认为heapsort应该比插入更好，但执行时间更适合插入。

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>
#include <algorithm>

using namespace std;

void swap(int &a, int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

void shift_down(int *tab, int n, int &max)
{
    if((2*n + 1) > max)
        return;

    if(tab[2*n+1] > tab[n])
    {
        swap(tab[2*n+1], tab[n]);
        shift_down(tab, 2*n+1, max);
    }

    if((2*n + 2) > max)
        return;
    if(tab[2*n+2] > tab[n])
    {
        swap(tab[2*n+2], tab[n]);
        shift_down(tab, 2*n+2, max);
    }
}

void shift_up(int *tab, int n)
{
    if(n <= 0)
        return;

    if(tab[(n-1)/2] < tab[n])
    {
        swap(tab[(n-1)/2], tab[n]);
        shift_up(tab, (n-1)/2);
    }
}

int main()
{
    srand(time(0));
    int size = 10000;
    int tab[size];
    int q_tab[size];
    int a_tab[size];
    for(int i = 0; i < size; ++i)
    {
        tab[i] = rand() % 10000;
        q_tab[i] = tab[i];
        a_tab[i] = tab[i];
    }

    //Measurment for heapsort
  clock_t begin = clock();

    for(int i = 0; i < size; ++i)
    {
        shift_up(tab, i);
    }
    for(int i = 0; i < size; ++i)
    {
        swap(tab[0], tab[size-i-1]);
        int max = size - i - 2;
        shift_down(tab, 0, max);
    }

  clock_t end = clock();
  double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
    cout << "Czas trwania sortowania heap: " << elapsed_secs << endl;

    //Measurment for insertion sort
  begin = clock();
    for(int i = 1; i < size; ++i)
    {
        int j = i - 1;
        int key = q_tab[i];
        while((j >= 0) && (q_tab[j] > key))
        {
            q_tab[j+1] = q_tab[j];
            --j;
        }
        q_tab[j+1] = key;
    }

  end = clock();
  elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
    cout << "Czas trwania sortowania insert: " << elapsed_secs << endl;

    //Measurment for std::sort
  begin = clock();

    sort(a_tab, a_tab+size);

  end = clock();
  elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
    cout << "Czas trwania sortowania wbudowanego: " << elapsed_secs << endl;
} 

我的实施有问题吗？我不想使用std :: swap进行优化。

编辑： 我测量了几次，总是插入时间更好。 我知道为了更好的比较时间应该是有效的。