這個氣泡如何快速排序？

Question

我遇到了一個非常快的氣泡排序算法...就像在0.03秒的時間內以反向排序順序對100,000個整數整型進行排序一樣。 我知道氣泡排序被認為是效率最低的排序算法之一，那么什么使這種算法更好呢？

我看到，如果在第一次通過時沒有任何項目互換（這意味着它已經被排序），它將停止排序，但這不會影響反向訂單的情況。

ps有人能想到一種更快地對這么多int進行排序的方法嗎？ 也許基數排序？

void sort(int list[], int n)
{
    int i; 
    int j; 
    int gap;
    int swapped = 1;
    int temp;
    gap = n;

    while (gap > 1 || swapped == 1)
    {
        gap = gap * 10 / 13;
        if (gap == 9 || gap == 10)
        {
            gap = 11;
        }
        if (gap < 1)
        {
            gap = 1;
        }
        swapped = 0;
        for (i = 0, j = gap; j < n; i++, j++)
        {
            if (list[i] > list[j])
            {
                temp = list[i];
                list[i] = list[j];
                list[j] = temp;
                swapped = 1;
            }
        }
    }
}

Answer 1

如所評論的，這是一種梳子 。

對於就地排序， 快速排序或堆排序會更快。 如果使用第二個臨時數組，則合並排序或計數/基數排序會更快。 計算/基數排序應該是最快的。

用於計數/基數排序的示例代碼。 在我的系統（Intel 2600K，3.4ghz）上，大約需要0.001秒。 可以對示例代碼進行一些優化（例如使用mIndex [j]的指針），但是我不確定編譯器是否已經在進行少量的代碼更改時就完成了大多數優化。 處理器開銷可能太小而導致內存帶寬成為限制因素。

typedef unsigned int UI32;

UI32 * RadixSort(UI32 * pData, UI32 * pTemp, size_t count)
{
size_t mIndex[4][256] = {0};            // index matrix
UI32 * pDst, * pSrc, * pTmp;
size_t i,j,m,n;
UI32 u;

    for(i = 0; i < count; i++){         // generate histograms
        u = pData[i];
        for(j = 0; j < 4; j++){
            mIndex[j][(size_t)(u & 0xff)]++;
            u >>= 8;
        }       
    }
    for(j = 0; j < 4; j++){             // convert to indices
        n = 0;
        for(i = 0; i < 256; i++){
            m = mIndex[j][i];
            mIndex[j][i] = n;
            n += m;
        }       
    }

    pDst = pTemp;                       // radix sort
    pSrc = pData;
    for(j = 0; j < 4; j++){
        for(i = 0; i < count; i++){
            u = pSrc[i];
            m = (size_t)(u >> (j<<3)) & 0xff;
            pDst[mIndex[j][m]++] = u;
        }
        pTmp = pSrc;
        pSrc = pDst;
        pDst = pTmp;
    }

    return(pSrc);
}

Answer 2

盡管它與冒泡排序相似，但我認為這是一個shell排序 ，它是冒泡排序的一種更快的變體。