Question

我遇到这种麻烦。我有一个包含这样的值的数组：

array = [ {SortTime : 123456, Operation : Assigning}, {SortTime : 4567 , Operation: Assigning}, {SortTime : 123456 , Operation: Assigned} ];

因此，如果我比较array [0]和array [2]，我想保留顺序，以便我有＆＃34;分配＆＃34;之前＆＃34;分配＆＃34;

这些数字中的每一个都是一个纪元数，所以我需要，如果算法使用两个等于数字，它会为这两个数字留下相同的初始顺序（如果我有数组[4] = 12345和数组[5] = 12345 ，我希望数组[4]和数组[5]不按顺序成为数组[5]和数组[4]。

    array.sort(function(a, b) {
        if (a.val.SortTime === b.val.SortTime) {
            return -1;
        } else {
            return a.val.SortTime - b.val.SortTime;
        }
    });

这样做很有效，因为经常在等号之间进行位置交换。如果我的解释不好，我很抱歉。提前谢谢！

Answer 1

你想要的是稳定的排序。有关stable sort algorithms

的列表，请参阅维基百科

这是merge sort implementation from Rosetta Code：

function merge(left, right, arr) {
  var a = 0;
 
  while (left.length && right.length) {
    arr[a++] = (right[0] < left[0]) ? right.shift() : left.shift();
  }
  while (left.length) {
    arr[a++] = left.shift();
  }
  while (right.length) {
    arr[a++] = right.shift();
  }
}
 
function mergeSort(arr) {
  var len = arr.length;
 
  if (len === 1) { return; }
 
  var mid = Math.floor(len / 2),
      left = arr.slice(0, mid),
      right = arr.slice(mid);
 
  mergeSort(left);
  mergeSort(right);
  merge(left, right, arr);
}
 
var arr = [1, 5, 2, 7, 3, 9, 4, 6, 8];
console.log(arr);
mergeSort(arr)
console.log(arr);

Answer 2

您可以向对象添加索引属性，然后按时间排序，然后按索引排序，以保持相同时间项的关系。

结果是稳定的结果，因为采用了索引。

＆＃13;

var array = [
        { SortTime: 123456, Operation: 'Assigning', index: 0 },
        { SortTime: 4567, Operation: 'Assigning', index: 1 },
        { SortTime: 123456, Operation: 'Assigned', index: 2 }
    ]; 

array.sort(function (a, b) {
    return a.SortTime - b.SortTime || a.index - b.index;
});

console.log(array);

＆＃13;

.as-console-wrapper { max-height: 100% !important; top: 0; }

＆＃13;

Answer 3

JSBin

有一个有效的例子

var arr = [ 
     { 
       SortTime: 123456, 
       Operation: 'first operator'
     }, {
       SortTime: 4567,
       Operation: Assigning
     }, {
       SortTime: 123456,
       Operation: 'second operator'
     }];

var copy = [...arr];

copy.sort(function(a, b) {
    if (a.val.SortTime === b.val.SortTime) {
        return arr.indexOf(a) - arr.indexOf(b);
    } else {
        return a.val.SortTime - b.val.SortTime;
    }
});

如何正确排序这些类型的数组？

3 个答案: