Question

_radixSort_0 = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
/*
RADIX SORT
Use 256 bins
Use shadow array
- Get counts
- Transform counts to pointers
- Sort from LSB - MSB
*/
function radixSort(intArr) {
    var cpy = new Int32Array(intArr.length);
    var c4 = [].concat(_radixSort_0); 
    var c3 = [].concat(_radixSort_0); 
    var c2 = [].concat(_radixSort_0);
    var c1 = [].concat(_radixSort_0); 
    var o4 = 0; var t4;
    var o3 = 0; var t3;
    var o2 = 0; var t2;
    var o1 = 0; var t1;
    var x;
    for(x=0; x<intArr.length; x++) {
        t4 = intArr[x] & 0xFF;
        t3 = (intArr[x] >> 8) & 0xFF;
        t2 = (intArr[x] >> 16) & 0xFF;
        t1 = (intArr[x] >> 24) & 0xFF ^ 0x80;
        c4[t4]++;
        c3[t3]++;
        c2[t2]++;
        c1[t1]++;
    }
    for (x=0; x<256; x++) {
        t4 = o4 + c4[x];
        t3 = o3 + c3[x];
        t2 = o2 + c2[x];
        t1 = o1 + c1[x];
        c4[x] = o4;
        c3[x] = o3;
        c2[x] = o2;
        c1[x] = o1;
        o4 = t4;
        o3 = t3;
        o2 = t2;
        o1 = t1;
    }
    for(x=0; x<intArr.length; x++) {
        t4 = intArr[x] & 0xFF;
        cpy[c4[t4]] = intArr[x];
        c4[t4]++;
    }
    for(x=0; x<intArr.length; x++) {
        t3 = (cpy[x] >> 8) & 0xFF;
        intArr[c3[t3]] = cpy[x];
        c3[t3]++;
    }
    for(x=0; x<intArr.length; x++) {
        t2 = (intArr[x] >> 16) & 0xFF;
        cpy[c2[t2]] = intArr[x];
        c2[t2]++;
    }
    for(x=0; x<intArr.length; x++) {
        t1 = (cpy[x] >> 24) & 0xFF ^ 0x80;
        intArr[c1[t1]] = cpy[x];
        c1[t1]++;
    }
    return intArr;
}

编辑：

到目前为止，最佳/唯一的主要优化是JS类型数组。对正常基数排序的阴影数组使用类型数组已经产生了最好的结果。我还能够使用JS内置的堆栈push / pop来快速排除一些额外的快速排序。

latest jsfiddle benchmark

Intel i7 870, 4GB, FireFox 8.0
2mil
radixSort(intArr): 172 ms
radixSortIP(intArr): 1738 ms
quickSortIP(arr): 661 ms
200k
radixSort(intArr): 18 ms
radixSortIP(intArr): 26 ms
quickSortIP(arr): 58 ms

看来标准的基数排序确实是这项工作流程的王者。如果有人有时间尝试循环展开或其他修改，我会很感激。

我有一个特定的用例，我希望在JavaScript中尽可能快地实现排序。客户端脚本将访问大型（50,000 - 2mil），未分类（基本上是随机的），整数（32位有符号）数组，然后需要对这些数据进行排序和显示。

我已经实现了相当快速的基数排序和快速排序jsfiddle benchmark，但对于我的上限数组长度，它们仍然相当慢。快速排序在我的上限数组大小上表现更好，而基数排序在我的下限上表现更好。

defaultSort is the built-in JavaScript array.sort with an integer compare function

Intel C2Q 9650, 4GB, FireFox 3.6
2mil
radixSortIP(intArr): 5554 ms
quickSortIP(arr): 1796 ms
200k
radixSortIP(intArr): 139 ms
quickSortIP(arr): 190 ms
defaultSort(intArr): 354 ms

Intel i7 870, 4GB, FireFox 8.0
2mil
radixSortIP(intArr): 990 ms
quickSortIP(arr): 882 ms
defaultSort(intArr): 3632 ms
200k
radixSortIP(intArr): 28 ms
quickSortIP(arr): 68 ms
defaultSort(intArr): 306 ms

问题

是否有更好的实现任何符合我的用例/需求的排序算法？
是否可以对我的现有基数/快速排序实施进行任何优化以提高性能？
- 有没有一种有效的方法可以将我的原位基数排序从递归函数转换为迭代函数？记忆和执行速度。

目标

我希望这些答案能帮助我在基准测试中获得约20-30％的性能提升。

澄清/备注

“快速定义”我更喜欢一种在所有现代浏览器上运行良好的一般情况，但是如果有一个特定于浏览器的优化可以实现可接受的重大改进。
排序可以在服务器端完成，但我更愿意避免这种情况，因为JS应用程序可能会成为一个独立的（与一些现成的专有应用程序配对，将传感器数据传输到文件）。
JavaScript可能不是最好的语言，但这是一项要求。
我已经问过这个问题https://stackoverflow.com/questions/7111525/fastest-way-to-sort-integer-arrays-in-javascript一个错误的答案已被投票，问题已经结束。
我尝试使用多个浏览器窗口实例作为临时多线程;它没有成功。我对有关生成多个并发窗口的有用信息感兴趣。

Answer 1

我测试了 typed arrays ，QSIP版本似乎在现代浏览器中表现不错：

2 000 000 元素

          QSIP_TYPED | RDXIP_TYPED |  QSIP_STD | RDXIP_STD
----------------------------------------------------------
Chrome  |    300          1000          600        1300
Firefox |    550          1500          800        1600

http://jsfiddle.net/u8t2a/35/

支持（来源： http://caniuse.com/typedarrays）：

 IE 10+   |   FF 4+  |  Chrome 7+  |  Safari 5.1+  |  Opera 11.6+

Answer 2

您是否考虑过多种算法组合来最大化缓存使用？我在基准测试中看到，当子阵列变小时，您将切换到插入排序。一个有趣的方法是转而使用heapsort。与quicksort结合使用时，它可以将最坏的情况降低到O（nlog（n））而不是O（n ^ 2）。看看Introsort。

Answer 3

我摆弄你的基准并添加了我自己的排序功能。它与radixsort执行相同，但它的想法（和实现）更简单，它就像一个radixsort，但在二进制中，所以你只有两个桶，可以就地做到这一点。请看http://jsfiddle.net/KaRV9/7/。

我把我的代码放在“Quicksort就位”的位置（因为它与quicksort非常相似，只是以其他方式选择了pivot）。运行它们几次，在我的Chrome 15中，它们表现得非常接近，无法区分它们。

Answer 4

我不打算对你的排序算法发表评论。你比我更了解这些。

但是一个好主意是使用网络工作者。这允许您的排序在它自己的线程中在后台运行，因此不会阻止接口。无论如何，这都是好习惯。 Chrome和Firefox都支持它。 Opera有一个非线程版本。不确定IE中的支持，但很容易解决这个问题。当然，使用多个线程涉及开销。

可以轻松地将合并排序转换为多线程版本，这将为您带来一些性能提升。消息传递当然会带来时间损失，因此如果它运行得更快，它将真正取决于您的具体情况。但请记住，非阻塞性质可能会使应用程序对最终用户的运行速度更快。

Answer 5

编辑：我发现你已经在使用插入排序来处理较小的子阵列了。我错过了。

快速排序的良好实际方法是检查子阵列的大小，如果它足够短，则使用快速的低开销排序，对于较大的阵列来说太慢，例如插入排序。

伪代码的含义如下：

quicksort(array, start, end):
  if ( (end-start) < THRESHOLD ) {
    insertion_sort(array, start, end);
    return;
  }
  // regular quicksort here
  // ...

要确定THRESHOLD，您需要在您关注的平台上进行计时 - 在您的情况下 - 可能是不同的浏览器。测量具有不同阈值的随机数组的时间，以找到接近最佳的数组。如果发现重大差异，您还可以为不同的浏览器选择不同的阈值。

现在，如果您的输入不是随机的（这很常见），您可以看到更好的数据透视选择是否可以提高性能。一种常见的方法是median of three。

在JavaScript中对32位有符号整数数组进行排序的最快方法？

编辑：

问题

目标

澄清/备注

5 个答案: