Javascript Array.sort实现?

时间:2008-10-24 18:08:14

标签: javascript algorithm arrays sorting

JavaScript Array#sort()函数使用哪种算法?我知道它可以采取各种各样的参数和函数来执行不同类型的排序,我只是对vanilla排序使用的算法感兴趣。

9 个答案:

答案 0 :(得分:261)

我刚看了一下WebKit(Chrome,Safari ......)source。根据数组的类型,使用不同的排序方法:

Numeric arrays(或基本类型的数组)使用C ++标准库函数std::qsort进行排序,该函数实现了快速排序的一些变体(通常是introsort)。

Contiguous arrays of non-numeric type使用mergesort进行字符串化和排序(如果可用)(以获得稳定的排序)或qsort如果没有可用的合并排序。

对于其他类型(非连续数组,可能是关联数组),WebKit使用selection sort(他们称之为“min” sort),或者在某些情况下,它通过AVL树进行排序。不幸的是,这里的文档相当模糊,因此您必须跟踪代码路径以实际查看哪种类型使用哪种排序方法。

然后有像this comment这样的宝石:

// FIXME: Since we sort by string value, a fast algorithm might be to use a
// radix sort. That would be O(N) rather than O(N log N).

- 让我们只希望实际上“修复”它的人比这个评论的作者更好地理解渐近运行时,并且意识到radix sort has a slightly more complex runtime description而不仅仅是O(N)。

(感谢phsource指出原始答案中的错误。)

答案 1 :(得分:59)

如果你看一下这个bug 224128,看来Mozilla正在使用MergeSort。

答案 2 :(得分:34)

JS没有草案要求使用特定的排序algorthim。正如许多人在这里提到的,Mozilla使用合并排序。但是,在Chrome的v8源代码中,截至今天,它使用QuickSort和InsertionSort,用于较小的阵列。

V8 Engine Source

来自807 - 891行

  var QuickSort = function QuickSort(a, from, to) {
    var third_index = 0;
    while (true) {
      // Insertion sort is faster for short arrays.
      if (to - from <= 10) {
        InsertionSort(a, from, to);
        return;
      }
      if (to - from > 1000) {
        third_index = GetThirdIndex(a, from, to);
      } else {
        third_index = from + ((to - from) >> 1);
      }
      // Find a pivot as the median of first, last and middle element.
      var v0 = a[from];
      var v1 = a[to - 1];
      var v2 = a[third_index];
      var c01 = comparefn(v0, v1);
      if (c01 > 0) {
        // v1 < v0, so swap them.
        var tmp = v0;
        v0 = v1;
        v1 = tmp;
      } // v0 <= v1.
      var c02 = comparefn(v0, v2);
      if (c02 >= 0) {
        // v2 <= v0 <= v1.
        var tmp = v0;
        v0 = v2;
        v2 = v1;
        v1 = tmp;
      } else {
        // v0 <= v1 && v0 < v2
        var c12 = comparefn(v1, v2);
        if (c12 > 0) {
          // v0 <= v2 < v1
          var tmp = v1;
          v1 = v2;
          v2 = tmp;
        }
      }
      // v0 <= v1 <= v2
      a[from] = v0;
      a[to - 1] = v2;
      var pivot = v1;
      var low_end = from + 1;   // Upper bound of elements lower than pivot.
      var high_start = to - 1;  // Lower bound of elements greater than pivot.
      a[third_index] = a[low_end];
      a[low_end] = pivot;

      // From low_end to i are elements equal to pivot.
      // From i to high_start are elements that haven't been compared yet.
      partition: for (var i = low_end + 1; i < high_start; i++) {
        var element = a[i];
        var order = comparefn(element, pivot);
        if (order < 0) {
          a[i] = a[low_end];
          a[low_end] = element;
          low_end++;
        } else if (order > 0) {
          do {
            high_start--;
            if (high_start == i) break partition;
            var top_elem = a[high_start];
            order = comparefn(top_elem, pivot);
          } while (order > 0);
          a[i] = a[high_start];
          a[high_start] = element;
          if (order < 0) {
            element = a[i];
            a[i] = a[low_end];
            a[low_end] = element;
            low_end++;
          }
        }
      }
      if (to - high_start < low_end - from) {
        QuickSort(a, high_start, to);
        to = low_end;
      } else {
        QuickSort(a, from, low_end);
        from = high_start;
      }
    }
  };

<强>更新 截至2018年,V8使用TimSort,感谢@celwell。 Source

答案 3 :(得分:21)

ECMAscript标准没有规定使用哪种排序算法。实际上,不同浏览器具有不同的排序算法例如,在对地图进行排序时,Mozilla / Firefox的sort()不是stable(在单词的排序意义上)。 IE的sort()是稳定的。

答案 4 :(得分:8)

经过一些研究后,对于Mozilla / Firefox来说,似乎Array.sort()使用了mergesort。请参阅代码here

答案 5 :(得分:6)

我认为这取决于您所引用的浏览器实现。

每种浏览器类型都有自己的javascript引擎实现,因此它取决于。 您可以检查Mozilla和Webkit / Khtml的源代码存储库以了解不同的实现。

IE是封闭的来源,所以你可能不得不在微软询问某人。

答案 6 :(得分:3)

从V8 v7.0 / Chrome 70开始,V8使用TimSort(Python的排序算法)。 Chrome 70于2018年9月13日发布。

有关此更改的详细信息,请参见the post on the V8 dev blog。您还可以阅读source codepatch 1186801

答案 7 :(得分:0)

JavaScript的Array.sort()函数具有内部机制,可以根据数组元素的数据类型选择最佳的排序算法(QuickSort,MergeSort等)。

答案 8 :(得分:0)

尝试快速排序:

function sort(arr, compareFn = (a, b) => a <= b) {

    if (!arr instanceof Array || arr.length === 0) {
        return arr;
    }

    if (typeof compareFn !== 'function') {
        throw new Error('compareFn is not a function!');
    }

    const partition = (arr, low, high) => {
        const pivot = arr[low];
        while (low < high) {
            while (low < high && compareFn(pivot, arr[high])) {
                --high;
            }
            arr[low] = arr[high];
            while (low < high && compareFn(arr[low], pivot)) {
                ++low;
            }
            arr[high] = arr[low];
        }
        arr[low] = pivot;
        return low;
    };

    const quickSort = (arr, low, high) => {
        if (low < high) {
            let pivot = partition(arr, low, high);
            quickSort(arr, low, pivot - 1);
            quickSort(arr, pivot + 1, high);
        }
        return arr;
    };

    return quickSort(arr, 0, arr.length - 1);
}