Question

几个小时我一直在试图弄清楚如何依赖于数组排序。

假设我有2个阵列。

第一个：

array1 = ['zzzzz', 'aaaaaa', 'ccccc'];

和第二个：

array2 = [3, 7, 1];

我使用array1.sort();对第一个进行排序，它变为[aaaaaa, cccccc, zzzzzz] 现在我想要的是第二个成为[7, 1, 3]

我认为这很简单，但我正试图在一些更复杂的东西中实现这一点，我是新的，并且我一直在混淆。

由于

Answer 1

我会将它们“压缩”成一个对象数组，然后使用自定义排序回调对其进行排序，然后将它们“解压缩”回所需的两个数组：

var array1 = ['zzzzz', 'aaaaaa', 'ccccc'],
    array2 = [3, 7, 1],
    zipped = [],
    i;

for(i=0; i<array1.length; ++i) {
    zipped.push({
        array1elem: array1[i],
        array2elem: array2[i]
    });
}

zipped.sort(function(left, right) {
    var leftArray1elem = left.array1elem,
        rightArray1elem = right.array1elem;

    return leftArray1elem === rightArray1elem ? 0 : (leftArray1elem < rightArray1elem ? -1 : 1);
});

array1 = [];
array2 = [];
for(i=0; i<zipped.length; ++i) {
    array1.push(zipped[i].array1elem);
    array2.push(zipped[i].array2elem);
}

alert('Sorted arrays:\n\narray1: ' + array1 + '\n\narray2: ' + array2);

这是working fiddle。

Answer 2

这是一个简单的功能，可以解决这个问题：

function sortTogether(array1, array2) {
    var merged = [];
    for(var i=0; i<array1.length; i++) { merged.push({'a1': array1[i], 'a2': array2[i]}); }
    merged.sort(function(o1, o2) { return ((o1.a1 < o2.a1) ? -1 : ((o1.a1 == o2.a1) ? 0 : 1)); });
    for(var i=0; i<merged.length; i++) { array1[i] = merged[i].a1; array2[i] = merged[i].a2; }
}

Usage demo (fiddle here)：

var array1 = ['zzzzz', 'aaaaaa', 'ccccc'];
var array2 = [3, 7, 1];
console.log('Before..: ',array1,array2);

sortTogether(array1, array2); // simply call the function

console.log('After...: ',array1,array2);

输出：

Before..:  ["zzzzz", "aaaaaa", "ccccc"] [3, 7, 1]
After...:  ["aaaaaa", "ccccc", "zzzzz"] [7, 1, 3]

Answer 3

您可以创建一个对象数组，而不是两个基本类型数组（字符串，数字），其中对象的一个属性是字符串（包含“aaaaa”，“cccccc”，“zzzzzz”），另一个是数字（7），1,3）。这样，您将只有一个数组，您can sort by any property和另一个属性将保持同步。

Answer 4

就是这样，我有一些旧代码可以解决这个问题：

function arrVirtualSortGetIndices(array,fnCompare){
    var index=array.map(function(e,i,a){return i;});
    fnCompare=fnCompare || defaultStringCompare;
    var idxCompare=function (aa,bb){return fnCompare(array[aa],array[bb]);};
    index.sort(idxCompare);
    return index;

    function defaultStringCompare(aa,bb){
        if(aa<bb)return -1;
        if(bb<aa)return 1;
        return 0;
    }
    function defaultNumericalCompare(aa,bb){
        return aa-bb;
    }   
}

function arrReorderByIndices(array,indices){
    return array.map(
        function(el,ix,ar){
            return ar[indices[ix]];
        }
    );
}

var array1 = ['zzzzz', 'aaaaaa', 'ccccc'];
var array2 = [3, 7, 1];
var indices=arrVirtualSortGetIndices(array1);
var array2sorted=arrReorderByIndices(array2,indices);
array2sorted;

/*
7,1,3
*/

对不起，我不做'fors'。至少不是在我不需要的时候。

fiddle。

另外，一个替代的fiddle在给定像这样的对象数组时对结果进行排序：

给出：

var list = [
    {str:'zzzzz',value:3},
    {str:'aaaaa',value:7},
    {str:'ccccc',value:1}
];

输出：

[
  {str: "aaaaa", value: 7},
  {str: "ccccc", value: 1},
  {str: "zzzzz", value: 3}
]

Answer 5

假设：

数组长度相同（这是您的问题所暗示的）
可以将内容与>和<进行比较（在您的示例中为true，但我想明确表示这是假设的）

那么我们可以使用插入排序。

var value,len = array1.length;
for (i=0; i < len; i++) {
        value = array1[i];
        for (j=i-1; j > -1 && array1[j] > value; j--) {
            array1[j+1] = array1[j];
            array2[j+1] = array2[j];
        }

        items[j+1] = value;
 }

Answer 6

使用找到here的解决方案在排序数组后查找新索引，您可以将这些索引应用于array2，如此。

function sortWithIndices(toSort) {
  for (var i = 0; i < toSort.length; i++) {
    toSort[i] = [toSort[i], i];
  }
  toSort.sort(function(left, right) {
    return left[0] < right[0] ? -1 : 1;
  });
  toSort.sortIndices = [];
  for (var j = 0; j < toSort.length; j++) {
    toSort.sortIndices.push(toSort[j][2]);
    toSort[j] = toSort[j][0];
  }
  return toSort;
}


var array1 = ['zzzz', 'aaaa', 'cccc'];
var array2 = [3, 7, 1];

// calculate the indices of array1 after sorting. (attached to array1.sortIndices)
sortWithIndices(array1);

// the final array after applying the sorted indices from array1 to array2
var final = [];

// apply sorted indices to array2
for(var i = 0; i < array1.sortIndices.length; i++)
    final[i] = array2[array1.sortIndices[i]];

// output results
alert(final.join(","));

<强> JSFiddle Demo

javascript，排序2依赖于数组

6 个答案: