Question

我一直致力于基数排序实现（到目前为止粘贴在下面的代码）。代码是Java，但在C / C ++中应该也可以。正如你从实现中看到的那样，我最重要的是第一位，整数的第31位。这似乎更快，因为一旦子组完成，就不再需要迭代了。

例如，作为一个类比，想象排序单词，你只有一个单词以“A”开头。一旦看到A并将单词放在列表的开头，就不再需要检查单词中的任何其他字符。另一方面，如果你从单词的 end 开始，你必须先查看每一个字母，然后才能发现它属于列表的开头。

所以，基于这个想法，我认为MSB订单会最快，但我错过了什么吗？ LSB是否因某种原因一样快？我知道LSB执行“稳定排序”，但我认为没有任何实际好处。

public static final int[] RadixSort_unsigned_1( int[] values1 ){ // one based key sorting
    int[] keys = new int[ values1.length ];
    int ctValues = values1[0];
    keys[0] = ctValues;
    for( int xKey = 1; xKey <= ctValues; xKey++ ) keys[xKey] = xKey;
    int iFrameListSize = (int)Math.sqrt( (double)ctValues ) + 2;
    int[] nextBottom = new int[ iFrameListSize ];
    int[] nextTop = new int[ iFrameListSize ];
    int ctFramesRemaining = 1;
    int ctFramesInNextRadix = 0;
    nextBottom[ 1 ] = 1; // the frame information is maintained in a circular queue
    nextTop[ 1 ] = ctValues;
    int xFrame = 1;
    int xFrameNextRadix = 2;
    int radix = 32;
    while( radix > 0 ){
        while( ctFramesRemaining > 0 ){ // go through all the frames and sort them
            int xLow = nextBottom[ xFrame ];
            int xHigh = nextTop[ xFrame ];
            while( true ){ // sort frame
                while( values1[ keys[ xLow ] ] == 0 ) xLow++;
                while( values1[ keys[ xHigh ] ] == 1 ) xHigh--;
                if( xLow > xHigh ) break;
                int iLowKey = keys[xLow]; // exchange high and low
                keys[xLow] = keys[xHigh];
                keys[xHigh] = iLowKey;
            }
            if( xHigh > nextBottom[ xFrame ] ){ // add a lower frame
                if( xLow < nextTop[ xFrame ] ){ // and also add an upper frame
                    xFrameNextRadix++;
                    nextBottom[ xFrameNextRadix ] = nextBottom[ xFrame ]; // bottom remains the same
                    nextTop[ xFrameNextRadix ] = xHigh;
                    xFrameNextRadix++;
                    nextBottom[ xFrameNextRadix ] = xLow;
                    nextTop[ xFrameNextRadix ] = nextTop[ xFrame ]; // top remains the same
                    ctFramesInNextRadix += 2;
                } else { // just add the lower frame
                    xFrameNextRadix++;
                    nextBottom[ xFrameNextRadix ] = nextBottom[ xFrame ]; // bottom remains the same
                    nextTop[ xFrameNextRadix ] = xHigh;
                    ctFramesInNextRadix++;
                }
            } else if( xLow < nextTop[ xFrame ] ){ // just add the upper frame
                xFrameNextRadix++;
                nextBottom[ xFrameNextRadix ] = xLow;
                nextTop[ xFrameNextRadix ] = nextTop[ xFrame ]; // top remains the same
                ctFramesInNextRadix++;
            } // otherwise add no new frames
            ctFramesRemaining--;
        }
        if( ctFramesInNextRadix == 0 ) break; // done
        radix--;
    }
    return keys;
}

注意，在该实现中，“基数”是二进制基数，即比特。

更新

BTW在Java中，它运行速度比内置的Arrays.sort快5倍（当我进行就地排序时，而不是键控排序），这非常酷。

Answer 1

所以，根据这个想法，我认为MSB订单会最快，但我错过了什么？

根据我的经验，递归MSD基数排序确实比LSD基数排序实现更快。然而，其原因主要不是你提到的那个（有效，但在实践中不太相关），而是这两者的组合：

缓存效率：MSD适用于递归实现。如果排序对象（数字，字符串，...）的数字合理地随机分布，从某个递归深度开始，整个子问题适合更快的CPU缓存。根据我的经验，减少高速缓存未命中数是设计算法时可以应用的最重要的常量优化，因为与典型CPU相比，主内存非常慢
在某个问题规模下，您可以使用insertion sort。如果已排序的对象足够小（例如，如果对整数进行排序）并且整个子数组适合缓存，则插入排序可能比其他任何排序算法更快。

你的实现不递归，所以它可能没有这些优势，这取决于它解决子问题的顺序（我没有真正分析算法，但如果你使用队列而不是堆栈，你可能没有很好的缓存局部性。）

我知道LSB执行“稳定排序”，但我认为没有任何实际好处。

有几个应用程序需要稳定属性。我想到的是suffix array construction。我写了一个简单的 O（n log n）算法来做answer to another SO question。它使用基数排序，并要求排序稳定。实际上有stable variations of MSD radix sort，但它们需要额外的内存。我不知道它们与LSD方法的比较。

基数排序最显着的第一或最不重要，哪个更快？

1 个答案: