这个气泡如何快速排序？

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排序 ，它是冒泡排序的一种更快的变体。