为什么快速排序的这种实现比qsort慢？

Question

Doing some refreshing on algorithms. I wrote this Quick sort implementation:

#define SWAP(X, Y, Type) { Type Temp = (X); (X) = (Y); (Y) = Temp; }

int QSPartition(int* Array, int StartIndex, int EndIndex)
{
    int PivotDestinationIndex = StartIndex;
    int Pivot = Array[EndIndex];
    for(int i = StartIndex; i <= EndIndex; i++)
    {
        if (Array[i] < Pivot)
        {
            SWAP(Array[i], Array[PivotDestinationIndex], int);
            PivotDestinationIndex++;
        }
    }
    SWAP(Array[PivotDestinationIndex], Array[EndIndex], int);
    return PivotDestinationIndex;
}

void QuickSort(int* Array, int StartIndex, int EndIndex)
{
    if (StartIndex >= EndIndex)
        return;

    int PivotIndex = QSPartition(Array, StartIndex, EndIndex);
    QuickSort(Array, PivotIndex + 1, EndIndex);
    QuickSort(Array, StartIndex, PivotIndex - 1);
}

In my main program:

#define Measure(Iterations, What, Code)\
{\
    clock_t Begin = clock();\
    for(int _im_ = 0; _im_ < Iterations; _im_++)\
    {\
        Code;\
    }\
    clock_t End = clock();\
    printf("Time took to " What ": %.1f ms\n", (double)(End - Begin));\
}

int CompareInt(const void* x, const void* y) { return *(int*)x - *(int*)y; }

int main()
{
    srand(time(0));

    int Count = 100000;
    int* Array0 = (int*)malloc(sizeof(int) * Count);
    int* Array1 = (int*)malloc(sizeof(int) * Count);

    for (int i = 0; i < Count; i++)
    {
        int RandomValue = rand() % 100;
        Array0[i] = RandomValue;
        Array1[i] = RandomValue;
    }

    Measure(1, "My Quick", QuickSort(Array0, 0, Count - 1));
    Measure(1, "C  Quick", qsort(Array1, Count, sizeof(int), CompareInt));

    getchar();
    return 0;
}

The output is that "My Quick" is always around 125 ms while "C Quick" is always around 25 ms . (32-bit DEBUG build - On RELEASE still the same 5 times slower)

What is going on? Why is my implementation slower? (I tried inlining the functions but it didn't do much) Is there something else wrong? (the way I'm timing this, or the way I'm populating the arrays with random values, or...?)

Answer 1

Try one of these, you'll need to change the std::swap to swap for C.

QuickSort using middle value for pivot:

void QuickSort(uint32_t a[], int lo, int hi) {
    int i = lo, j = hi;
    uint32_t pivot = a[(lo + hi) / 2];
    while (i <= j) {            // partition
        while (a[i] < pivot)
            i++;
        while (a[j] > pivot)
            j--;
        if (i <= j) {
            std::swap(a[i], a[j]);
            i++;
            j--;
        }
    }
    if (lo < j)                 // recurse
        QuickSort(a, lo, j);
    if (i < hi)
        QuickSort(a, i, hi);
}

QuickSort using median of low, middle, high, values as pivot

void QuickSort(uint32_t a[], int lo, int hi) {
    int i = lo, j = (lo + hi)/2, k = hi;
    uint32_t pivot;
    if (a[k] < a[i])            // median of 3
        std::swap(a[k], a[i]);
    if (a[j] < a[i])
        std::swap(a[j], a[i]);
    if (a[k] < a[j])
        std::swap(a[k], a[j]);
    pivot = a[j];
    while (i <= k) {            // partition
        while (a[i] < pivot)
            i++;
        while (a[k] > pivot)
            k--;
        if (i <= k) {
            std::swap(a[i], a[k]);
            i++;
            k--;
        }
    }
    if (lo < k)                 // recurse
        QuickSort(a, lo, k);
    if (i < hi)
        QuickSort(a, i, hi);
}