Javascript, sort 2 array

Ответ 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);

Здесь рабочая скрипка.

Ответ 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; }
}

Демо-версия использования (скрипка здесь):

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] 

Ответ 3

Вместо двух массивов примитивных типов (строк, чисел) вы можете создать массив объектов, где одно свойство объекта является строкой (содержащей "aaaaa", "cccccc", "zzzzzz" ), а другое - число (7, 1,3). Таким образом, у вас будет только один массив, который вы можете сортировать по любому свойству, а другое свойство останется в синхронизации.

Ответ 4

Предположение:

• Массивы имеют одинаковую длину (это подразумевается вашим вопросом)
• содержимое можно сравнить с > и < (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;
 }

Ответ 5

Так получилось, что у меня был старый код, который мог бы сделать трюк:

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

Ответ 6

Используя найденное решение здесь, чтобы найти новые индексы после сортировки массива, вы можете применить эти индексы к 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