使用first元素作為pivot在C中進行Quicksort實現

Question

我是stackoverflow的完全初學者，這是我的第一篇文章。 如果這不是發布這類查詢的正確位置，請原諒。 我已經為Quicksort算法編寫了代碼，基於Coursera中算法課程中給出的算法（雖然它不適用於任何作業）。

基本上，有兩個函數Quicksort ，它們被稱為遞歸，而partition（）函數則返回pivot的索引。 我每次都選擇pivot作為數組的第一個元素。 我檢查了partition（）函數，它工作正常，但即使我調用Quicksort()函數后數組也沒有排序。

任何幫助表示贊賞。 謝謝。

    #include <stdio.h>
    void swap(int *p, int i, int j)
    {
        int temp = *(p+i);
        *(p+i) = *(p+j);
        *(p+j) = temp;
    }

    int partition(int *q, int l, int r)
    {
        int i = l+1, j;
        int p = l;
        int len  = r-l +1;
        for (j = l+1; j < len; j++)
        {
            /*printf("%d \n", j);*/
            if ( *(q+j) < *(q+p) )
            {
                swap(q, i, j);
                i += 1;
            }
        }
        swap(q, l, i-1);
        /*printf("%d", i-1);*/
        return (i-1);
    }

    void quicksort(int *ptr, int low, int high)
    {
        if (low < high)
        {
            int p = partition(ptr, low, high);
            printf("%d\n", p);
            quicksort(ptr, low, p);
            quicksort(ptr, p+1, high);
        }
    }


    int main(){
        int i;
        int a[] = {3, 8, 2, 5, 1, 4, 7, 6};
        int len  = sizeof(a)/sizeof(a[0]);
        for ( i = 0; i < len; ++i)
        {
            printf("%d ", a[i]);
        }
        printf("\n");
        int *ptr = a;
        quicksort(ptr, 0, len-1);
        for (i = 0; i < sizeof(a)/sizeof(a[0]); ++i)
        {
            printf("%d ", a[i]);
        }
        printf("\n");
        return 0;
    }

Answer 1

2次更正。

小一：如果在QuickSort功能中阻止，則在內部更改第3行

從

quicksort(ptr, low, p);

至

quicksort(ptr, low, p-1);

這將提高性能。

主要錯誤：

你的分區功能是錯誤的。 特別是j從l+1到r-l+1的循環，因為， r-l+1可以小於l+1

如果你願意，我會為你編寫分區函數（如果你遇到任何問題，可以發表評論）雖然我建議你自己做。

編輯：

可能的分區功能：

int partition(int *q, int l, int r){
    int i,j;
    int p = *(q + l);
    for(i = l + 1, j = r; ;){
        while(*(q + i) <= p)
            i++;
        while(*(q + j) >= p)
            j--;
        if(i >= j)
            break;
        swap(q, i, j);
    }
    return i;
}

Answer 2

評論中注明的變化。

int partition(int *q, int l, int r)
{
    int i = l+1, j;
    int p = l;
                                    /* fix: int len = r-l+1; is not used */
    for (j = l+1; j <= r; j++)      /* fix: j <= r */
    {
        if ( *(q+j) <= *(q+p) )     /* fix: <= */
        {
            swap(q, i, j);
            i += 1;
        }
    }
    swap(q, l, i-1);
    return (i-1);
}

void quicksort(int *ptr, int low, int high)
{
    if (low < high)
    {
        int p = partition(ptr, low, high);
        quicksort(ptr, low, p-1);   /* optimization: p-1 */
        quicksort(ptr, p+1, high);
    }
}

如果有興趣，Hoare分區方案更快。 如果切換到此，請不要忘記將兩個快速排序調用更改為快速排序（lo，p）和快速排序（p + 1，hi））。 您可能希望將Hoare pivot更改為pivot = A [（lo + hi）/ 2]，這將避免排序或反向排序數組的最壞情況問題。

http://en.wikipedia.org/wiki/Quicksort#Hoare_partition_scheme