JavaScriptでの高速で安定したソートアルゴリズムの実装
特定のキーと特定の順序（asc/desc）で並べ替えて、約200〜300個のオブジェクトの配列を並べ替えたいと考えています。結果の順序は一貫して安定している必要があります。
使用するのに最適なアルゴリズムは何ですか？また、javascriptでの実装の例を提供できますか？
ありがとう！
不安定なソート関数から安定したソートを取得することが可能です。
ソートする前に、すべての要素の位置を取得します。ソート条件では、両方の要素が等しい場合、位置でソートします。
多田！安定したソートがあります。
このテクニックとその実装方法について詳しく知りたい場合は、ブログに記事を書いています。 http://blog.vjeux.com/2010/javascript/javascript-sorting-table。 html
安定したものを探しているので、マージソートで十分です。
http://www.stoimen.com/blog/2010/07/02/friday-algorithms-javascript-merge-sort/
コードは上記のウェブサイトで見つけることができます：
function mergeSort(arr)
{
if (arr.length < 2)
return arr;
var middle = parseInt(arr.length / 2);
var left = arr.slice(0, middle);
var right = arr.slice(middle, arr.length);
return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right)
{
var result = [];
while (left.length && right.length) {
if (left[0] <= right[0]) {
result.Push(left.shift());
} else {
result.Push(right.shift());
}
}
while (left.length)
result.Push(left.shift());
while (right.length)
result.Push(right.shift());
return result;
}
編集：
この post によると、一部の実装ではArray.Sortがマージソートを使用しているように見えます。
私はこの質問にしばらく答えていることを知っていますが、私はクリップボードにArrayとjQueryの安定したマージソート実装がありますので、将来の検索者が役に立つかもしれないと期待して共有します。
通常のArray.sort実装と同様に、独自の比較関数を指定できます。
実装
// Add stable merge sort to Array and jQuery prototypes
// Note: We wrap it in a closure so it doesn't pollute the global
// namespace, but we don't put it in $(document).ready, since it's
// not dependent on the DOM
(function() {
// expose to Array and jQuery
Array.prototype.mergeSort = jQuery.fn.mergeSort = mergeSort;
function mergeSort(compare) {
var length = this.length,
middle = Math.floor(length / 2);
if (!compare) {
compare = function(left, right) {
if (left < right)
return -1;
if (left == right)
return 0;
else
return 1;
};
}
if (length < 2)
return this;
return merge(
this.slice(0, middle).mergeSort(compare),
this.slice(middle, length).mergeSort(compare),
compare
);
}
function merge(left, right, compare) {
var result = [];
while (left.length > 0 || right.length > 0) {
if (left.length > 0 && right.length > 0) {
if (compare(left[0], right[0]) <= 0) {
result.Push(left[0]);
left = left.slice(1);
}
else {
result.Push(right[0]);
right = right.slice(1);
}
}
else if (left.length > 0) {
result.Push(left[0]);
left = left.slice(1);
}
else if (right.length > 0) {
result.Push(right[0]);
right = right.slice(1);
}
}
return result;
}
})();
使用例
var sorted = [
'Finger',
'Sandwich',
'sandwich',
'5 pork rinds',
'a guy named Steve',
'some noodles',
'mops and brooms',
'Potato Chip Brand® chips'
].mergeSort(function(left, right) {
lval = left.toLowerCase();
rval = right.toLowerCase();
console.log(lval, rval);
if (lval < rval)
return -1;
else if (lval == rval)
return 0;
else
return 1;
});
sorted == ["5 pork rinds", "a guy named Steve", "Finger", "mops and brooms", "Potato Chip Brand® chips", "Sandwich", "sandwich", "some noodles"];
矢印関数や分割などのES2017機能を使用した同じもののやや短いバージョン：
関数
_var stableSort = (arr, compare) => arr
.map((item, index) => ({item, index}))
.sort((a, b) => compare(a.item, b.item) || a.index - b.index)
.map(({item}) => item)
_入力配列と比較関数を受け入れます：
_stableSort([5,6,3,2,1], (a, b) => a - b)
_また、組み込みの Array.sort（） 関数のようなインプレースソートを行う代わりに、新しい配列を返します。
テスト
最初にinputでソートされた次のweight配列を使用する場合：
_// sorted by weight
var input = [
{ height: 100, weight: 80 },
{ height: 90, weight: 90 },
{ height: 70, weight: 95 },
{ height: 100, weight: 100 },
{ height: 80, weight: 110 },
{ height: 110, weight: 115 },
{ height: 100, weight: 120 },
{ height: 70, weight: 125 },
{ height: 70, weight: 130 },
{ height: 100, weight: 135 },
{ height: 75, weight: 140 },
{ height: 70, weight: 140 }
]
_次に、heightを使用してstableSortでソートします。
_stableSort(input, (a, b) => a.height - b.height)
_結果：
_// Items with the same height are still sorted by weight
// which means they preserved their relative order.
var stable = [
{ height: 70, weight: 95 },
{ height: 70, weight: 125 },
{ height: 70, weight: 130 },
{ height: 70, weight: 140 },
{ height: 75, weight: 140 },
{ height: 80, weight: 110 },
{ height: 90, weight: 90 },
{ height: 100, weight: 80 },
{ height: 100, weight: 100 },
{ height: 100, weight: 120 },
{ height: 100, weight: 135 },
{ height: 110, weight: 115 }
]
_ただし、組み込みのArray.sort()（Chrome/NodeJS）を使用して同じinput配列をソートします。
_input.sort((a, b) => a.height - b.height)
_戻り値：
_var unstable = [
{ height: 70, weight: 140 },
{ height: 70, weight: 95 },
{ height: 70, weight: 125 },
{ height: 70, weight: 130 },
{ height: 75, weight: 140 },
{ height: 80, weight: 110 },
{ height: 90, weight: 90 },
{ height: 100, weight: 100 },
{ height: 100, weight: 80 },
{ height: 100, weight: 135 },
{ height: 100, weight: 120 },
{ height: 110, weight: 115 }
]
_資源
更新
_
Array.prototype.sort_はV8 v7.0で安定しました/ Chrome 70！以前は、V8は10個を超える要素を持つ配列に不安定なQuickSortを使用していました。ここで、安定したTimSortアルゴリズムを使用します。
次のポリフィルを使用して、ネイティブ実装に関係なく、行われたアサーションに基づいて安定したソートを実装できます この回答では ：
_// ECMAScript 5 polyfill
Object.defineProperty(Array.prototype, 'stableSort', {
configurable: true,
writable: true,
value: function stableSort (compareFunction) {
'use strict'
var length = this.length
var entries = Array(length)
var index
// wrap values with initial indices
for (index = 0; index < length; index++) {
entries[index] = [index, this[index]]
}
// sort with fallback based on initial indices
entries.sort(function (a, b) {
var comparison = Number(this(a[1], b[1]))
return comparison || a[0] - b[0]
}.bind(compareFunction))
// re-map original array to stable sorted values
for (index = 0; index < length; index++) {
this[index] = entries[index][1]
}
return this
}
})
// usage
const array = Array(500000).fill().map(() => Number(Math.random().toFixed(4)))
const alwaysEqual = () => 0
const isUnmoved = (value, index) => value === array[index]
// not guaranteed to be stable
console.log('sort() stable?', array
.slice()
.sort(alwaysEqual)
.every(isUnmoved)
)
// guaranteed to be stable
console.log('stableSort() stable?', array
.slice()
.stableSort(alwaysEqual)
.every(isUnmoved)
)
// performance using realistic scenario with unsorted big data
function time(arrayCopy, algorithm, compare) {
var start
var stop
start = performance.now()
algorithm.call(arrayCopy, compare)
stop = performance.now()
return stop - start
}
const ascending = (a, b) => a - b
const msSort = time(array.slice(), Array.prototype.sort, ascending)
const msStableSort = time(array.slice(), Array.prototype.stableSort, ascending)
console.log('sort()', msSort.toFixed(3), 'ms')
console.log('stableSort()', msStableSort.toFixed(3), 'ms')
console.log('sort() / stableSort()', (100 * msSort / msStableSort).toFixed(3) + '%')_上記で実装したパフォーマンステストを実行すると、stableSort()は、Chromeバージョン59-61）でsort()の速度の約57％で実行されるように見えます。
.bind(compareFunction)内のラップされた匿名関数でstableSort()を使用すると、各呼び出しでcompareFunctionへの不要なスコープ付き参照を割り当てることにより、相対パフォーマンスが約38％向上しました。代わりにコンテキスト。
更新
三項演算子を論理的短絡に変更しました。これは平均してパフォーマンスが向上する傾向があります（効率が2〜3％異なるようです）。
以下は、指定された比較関数を適用することにより、指定された配列をソートし、比較関数が0を返したときに元のインデックス比較を返します。
function stableSort(arr, compare) {
var original = arr.slice(0);
arr.sort(function(a, b){
var result = compare(a, b);
return result === 0 ? original.indexOf(a) - original.indexOf(b) : result;
});
return arr;
}
次の例では、姓で名前の配列をソートし、等しい姓の順序を保持します。
var names = [
{ surname: "Williams", firstname: "Mary" },
{ surname: "Doe", firstname: "Mary" },
{ surname: "Johnson", firstname: "Alan" },
{ surname: "Doe", firstname: "John" },
{ surname: "White", firstname: "John" },
{ surname: "Doe", firstname: "Sam" }
]
function stableSort(arr, compare) {
var original = arr.slice(0);
arr.sort(function(a, b){
var result = compare(a, b);
return result === 0 ? original.indexOf(a) - original.indexOf(b) : result;
});
return arr;
}
stableSort(names, function(a, b) {
return a.surname > b.surname ? 1 : a.surname < b.surname ? -1 : 0;
})
names.forEach(function(name) {
console.log(name.surname + ', ' + name.firstname);
});Timsortを使用することもできます。これは非常に複雑なアルゴリズムです（400行以上なので、ソースコードはありません）。 Wikipediaの説明 を参照するか、既存のJavaScript実装のいずれかを使用します。
GPL 3実装 。 Array.prototype.timsortとしてパッケージ化されています。 Javaコードの正確な書き直しのようです。
パブリックドメインの実装 チュートリアルとしての意味、サンプルコードは整数での使用のみを示しています。
Timsortは、マージソートとシャッフルソートの高度に最適化されたハイブリッドであり、PythonおよびJava（1.7+）のデフォルトのソートアルゴリズムです。これは複雑なアルゴリズムです。 、多くの特別な場合に異なるアルゴリズムを使用しているためですが、その結果、さまざまな状況下で非常に高速です。
これが安定した実装です。ネイティブの並べ替えを使用して機能しますが、要素が等しいと比較される場合、元のインデックス位置を使用してタイを壊します。
function stableSort(arr, cmpFunc) {
//wrap the arr elements in wrapper objects, so we can associate them with their origional starting index position
var arrOfWrapper = arr.map(function(elem, idx){
return {elem: elem, idx: idx};
});
//sort the wrappers, breaking sorting ties by using their elements orig index position
arrOfWrapper.sort(function(wrapperA, wrapperB){
var cmpDiff = cmpFunc(wrapperA.elem, wrapperB.elem);
return cmpDiff === 0
? wrapperA.idx - wrapperB.idx
: cmpDiff;
});
//unwrap and return the elements
return arrOfWrapper.map(function(wrapper){
return wrapper.elem;
});
}
非徹底的なテスト
var res = stableSort([{a:1, b:4}, {a:1, b:5}], function(a, b){
return a.a - b.a;
});
console.log(res);
別の答え これを暗示するが、codezを投稿しなかった。
しかし、私の ベンチマーク によると高速ではありません。 merge sort impl を変更してカスタムコンパレーター関数を受け入れましたが、はるかに高速でした。
http://www.stoimen.com/blog/2010/07/02/friday-algorithms-javascript-merge-sort/ からの単純なマージ
var a = [34, 203, 3, 746, 200, 984, 198, 764, 9];
function mergeSort(arr)
{
if (arr.length < 2)
return arr;
var middle = parseInt(arr.length / 2);
var left = arr.slice(0, middle);
var right = arr.slice(middle, arr.length);
return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right)
{
var result = [];
while (left.length && right.length) {
if (left[0] <= right[0]) {
result.Push(left.shift());
} else {
result.Push(right.shift());
}
}
while (left.length)
result.Push(left.shift());
while (right.length)
result.Push(right.shift());
return result;
}
console.log(mergeSort(a));
多次元配列を任意の列でソートしてから、別の列でソートする必要があります。この関数を使用して並べ替えます：
function sortMDArrayByColumn(ary, sortColumn){
//Adds a sequential number to each row of the array
//This is the part that adds stability to the sort
for(var x=0; x<ary.length; x++){ary[x].index = x;}
ary.sort(function(a,b){
if(a[sortColumn]>b[sortColumn]){return 1;}
if(a[sortColumn]<b[sortColumn]){return -1;}
if(a.index>b.index){
return 1;
}
return -1;
});
}
Ary.sortはゼロを返さないことに注意してください。これは、「ソート」関数の一部の実装が正しくない可能性がある決定を行う場所です。
これも非常に高速です。
そのため、React + Reduxアプリには安定した並べ替えが必要でしたが、ここでのVjeuxの答えが役に立ちました。ただし、私の（一般的な）ソリューションは、これまでに見てきた他のソリューションとは異なるようですので、他の誰かが一致するユースケースを持っている場合に備えて共有しています
- コンパレータ関数を渡すことができる
sort()APIに似たものが欲しいだけです。 - 時々私はcanをその場でソートし、時にはデータが不変で（Reduxのため）、代わりにソートされたコピーが必要です。そのため、ユースケースごとに安定したソート機能が必要です。
- ES2015。
私の解決策は、indicesの型付き配列を作成し、比較関数を使用して、これらのindicesを並べ替える配列に基づいて並べ替えることです。次に、並べ替えられたindicesを使用して、元の配列を並べ替えるか、単一のパスで並べ替えられたコピーを作成します。わかりにくい場合は、次のように考えてください。通常、次のような比較関数を渡します。
(a, b) => {
/* some way to compare a and b, returning -1, 0, or 1 */
};
代わりに以下を使用します。
(i, j) => {
let a = arrayToBeSorted[i], b = arrayToBeSorted[j];
/* some way to compare a and b, returning -1 or 1 */
return i - j; // fallback when a == b
}
速度は良いです。基本的には、組み込みのソートアルゴリズムに加えて、最後に2つの線形パスと、ポインタ間接オーバーヘッドの1つの追加レイヤーがあります。
このアプローチに関するフィードバックを喜んで受け取ります。これが私の完全な実装です：
/**
* - `array`: array to be sorted
* - `comparator`: closure that expects indices `i` and `j`, and then
* compares `array[i]` to `array[j]` in some way. To force stability,
* end with `i - j` as the last "comparison".
*
* Example:
* ```
* let array = [{n: 1, s: "b"}, {n: 1, s: "a"}, {n:0, s: "a"}];
* const comparator = (i, j) => {
* const ni = array[i].n, nj = array[j].n;
* return ni < nj ? -1 :
* ni > nj ? 1 :
* i - j;
* };
* stableSortInPlace(array, comparator);
* // ==> [{n:0, s: "a"}, {n:1, s: "b"}, {n:1, s: "a"}]
* ```
*/
function stableSortInPlace(array, comparator) {
return sortFromIndices(array, findIndices(array, comparator));
}
function stableSortedCopy(array, comparator){
let indices = findIndices(array, comparator);
let sortedArray = [];
for (let i = 0; i < array.length; i++){
sortedArray.Push(array[indices[i]]);
}
return sortedArray;
}
function findIndices(array, comparator){
// Assumes we don't have to worry about sorting more than
// 4 billion elements; if you know the upper bounds of your
// input you could replace it with a smaller typed array
let indices = new Uint32Array(array.length);
for (let i = 0; i < indices.length; i++) {
indices[i] = i;
}
// after sorting, `indices[i]` gives the index from where
// `array[i]` should take the value from, so to sort
// move the value at at `array[indices[i]]` to `array[i]`
return indices.sort(comparator);
}
// If I'm not mistaken this is O(2n) - each value is moved
// only once (not counting the vacancy temporaries), and
// we also walk through the whole array once more to check
// for each cycle.
function sortFromIndices(array, indices) {
// there might be multiple cycles, so we must
// walk through the whole array to check.
for (let k = 0; k < array.length; k++) {
// advance until we find a value in
// the "wrong" position
if (k !== indices[k]) {
// create vacancy to use "half-swaps" trick,
// props to Andrei Alexandrescu
let v0 = array[k];
let i = k;
let j = indices[k];
while (j !== k) {
// half-swap next value
array[i] = array[j];
// array[i] now contains the value it should have,
// so we update indices[i] to reflect this
indices[i] = i;
// go to next index
i = j;
j = indices[j];
}
// put original array[k] back in
// and update indices
array[i] = v0;
indices[i] = i;
}
}
return array;
}
以下は、MERGE SORTを利用するプロトタイプメソッドでJSのデフォルトのArrayオブジェクトを拡張する方法です。このメソッドは、特定のキー（最初のパラメーター）と特定の順序（2番目のパラメーターとして 'asc'/'desc'）で並べ替えることができます
Array.prototype.mergeSort = function(sortKey, direction){
var unsortedArray = this;
if(unsortedArray.length < 2) return unsortedArray;
var middle = Math.floor(unsortedArray.length/2);
var leftSubArray = unsortedArray.slice(0,middle).mergeSort(sortKey, direction);
var rightSubArray = unsortedArray.slice(middle).mergeSort(sortKey, direction);
var sortedArray = merge(leftSubArray, rightSubArray);
return sortedArray;
function merge(left, right) {
var combined = [];
while(left.length>0 && right.length>0){
var leftValue = (sortKey ? left[0][sortKey] : left[0]);
var rightValue = (sortKey ? right[0][sortKey] : right[0]);
combined.Push((direction === 'desc' ? leftValue > rightValue : leftValue < rightValue) ? left.shift() : right.shift())
}
return combined.concat(left.length ? left : right)
}
}上記のスニペットをブラウザコンソールにドロップして、これを自分でテストできます。
var x = [2,76,23,545,67,-9,12];
x.mergeSort(); //[-9, 2, 12, 23, 67, 76, 545]
x.mergeSort(undefined, 'desc'); //[545, 76, 67, 23, 12, 2, -9]
または、オブジェクトの配列内の特定のフィールドに基づいた順序：
var y = [
{startTime: 100, value: 'cat'},
{startTime: 5, value: 'dog'},
{startTime: 23, value: 'fish'},
{startTime: 288, value: 'pikachu'}
]
y.mergeSort('startTime');
y.mergeSort('startTime', 'desc');
ソートのカウントはマージソートより速く（O(n)時間で実行））、整数での使用を目的としています。
Math.counting_sort = function (m) {
var i
var j
var k
var step
var start
var Output
var hash
k = m.length
Output = new Array ()
hash = new Array ()
// start at lowest possible value of m
start = 0
step = 1
// hash all values
i = 0
while ( i < k ) {
var _m = m[i]
hash [_m] = _m
i = i + 1
}
i = 0
j = start
// find all elements within x
while ( i < k ) {
while ( j != hash[j] ) {
j = j + step
}
Output [i] = j
i = i + 1
j = j + step
}
return Output
}
例：
var uArray = new Array ()<br/>
var sArray = new Array ()<br/><br/>
uArray = [ 10,1,9,2,8,3,7,4,6,5 ]<br/>
sArray = Math.counting_sort ( uArray ) // returns a sorted array
私はこれが十分に答えられたことを知っています。私は、それを探してここに上陸した人のために、簡単なTS実装の投稿をしたかっただけです。
export function stableSort<T>( array: T[], compareFn: ( a: T, b: T ) => number ): T[] {
const indices = array.map( ( x: T, i: number ) => ( { element: x, index: i } ) );
return indices.sort( ( a, b ) => {
const order = compareFn( a.element, b.element );
return order === 0 ? a.index - b.index : order;
} ).map( x => x.element );
}
このメソッドは、ネイティブソートのようにインプレースで実行されなくなりました。また、これは最も効率的ではないことを指摘したいと思います。 O（n）の順序の2つのループを追加します。ただし、ソート自体はO（n log（n））である可能性が高いため、それよりも小さくなります。
上記のソリューションのいくつかは、内部Array.prototype.sort。
（Javascriptソリューションの場合、すべてのタイプを削除するだけです）