Javascript，排序2数组依赖

我会将它们"压缩"到一个对象数组中，然后使用自定义排序回调进行排序，然后将它们"解压缩"回您想要的两个数组:

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);

这里有一个简单的函数可以做到这一点:

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; }
}

用法演示:

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] 

不用两个基本类型的数组(字符串，数字)，你可以创建一个对象数组，其中对象的一个属性是string(包含"aaaaa"， "cccccc"， "zzzzzz")，另一个属性是number(7,1,3)。这样，您将只有一个数组，您可以按任何属性对其排序，而另一个属性将保持同步。

碰巧我有一些旧的代码可以做到这一点:

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
*/

对不起，我不做"for"。至少在我不需要的时候不会。

和小提琴。

另外，当给定一个对象数组时，还可以对结果进行排序，如下所示:

:

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}
]

假设:

• 数组长度相同(这是你的问题所暗示的)
• 内容可以与>和<进行比较(在您的示例中为真，但我想明确的是，这里是假设的)

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

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;
 }

使用这里找到的解决方案来查找数组排序后的新索引，您可以将这些索引应用于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(","));