Question

在javascript中，我有一个数组：

letterArray ['a', 'e', 'i', 'o', 'u']

对应于那个数组，我有另一个数组：

valueArray [12, 22, 7, 7, 3]

我想将valueArray排序为

[22, 12, 7, 7, 3]

但是letterArray也需要以相同的方式排序：

['e', 'a', 'i', 'o', 'u']

我怎么能这样做？

Answer 1

方法1：将你的两个数组压缩成一个拉链式的东西，比如[[12,'a'], [22, 'e'], [7, 'i'], [7, 'o'], [3, 'u']]，然后对得到的数组进行排序。然后就读掉这些字母。这样做的好处是你可以使用内置的排序算法，你只需要编写访问器。

方法2：滚动自己的排序算法，每次执行更改int数组的操作时，都要对字母数组执行相应的操作。

我推荐方法1。

Answer 2

您可以使用压缩方法执行此操作。我会使用_.zip。

// [["a", 12], ["e", 22], ...]
var arr = _.zip(letterArray, valueArray); // zip them up.
// sort
// [["u", 3], ["i", 7] OR ["o", 7], ...]
var sortedArr = _.sortBy(arr, function(val) {
    // sort by the value array.
    return val[1];
});
// pluck the letter array back out
// ["u", "i" OR "o", ...]
var newLetterArray = _.pluck(sortedArr, "0");
// pluck the value array back out
// [3, 7, 7, ...]
var newValueArray = _.pluck(sortedArr, "1");

我担心你的例子很复杂，因为有重复的数字，这意味着你无法在排序时获得订单。这是浏览器特定的，无论“i”还是“o”是第一位的。

Answer 3

// myArray.zip interleaves N arrays into one array of all pieces
// e.g. [1,2,3].zip([4,5,6],[7,8,9]) -> [ [1,4,7], [2,5,8], [3,6,9] ]
(function(o){
  var zip = function(){
    var argLen = arguments.length;
    var result = new Array(this.length);
    for (var i=this.length-1;i>=0;--i){
    var a = result[i] = [this[i]];
    for (var j=0;j<argLen;++j) a[j+1] = arguments[j][i];
    }
    return result;
  }
  if (Object.defineProperty) Object.defineProperty(o,"zip",{value:zip});
  else o.zip = zip;
})(Array.prototype);

var letters = ['a', 'e', 'i', 'o', 'u'];
var values  = [12, 22, 7, 7, 3];
var valuesAndLetters = values.zip(letters);
// [[12,"a"],[22,"e"],[7,"i"],[7,"o"],[3,"u"]]

var sorted = valuesAndLetters.sort(function(a,b){
  // Sort in descending order, first by value, then by letter
  return a[0]<b[0]?1:a[0]>b[0]?-1:a[1]<b[1]?1:a[1]>b[1]?-1:0;
});
// [[22,"e"],[12,"a"],[7,"o"],[7,"i"],[3,"u"]]

修改：如果您没有（或想要依赖）defineProperty，并且不希望将Array.prototype扩展为后备，那么这里是zip版本不接触任何人的原型：

// Interleaves N arrays into one array of all pieces
// e.g. Array.zip([1,2,3],[4,5,6],[7,8,9]) -> [ [1,4,7], [2,5,8], [3,6,9] ]
Array.zip = function zip(a0,a1,etc,aN){
  var argLen = arguments.length;
  var result = new Array(a0.length);
  for (var i=a0.length-1;i>=0;--i){
    var a = result[i] = [a0[i]];
    for (var j=1;j<argLen;++j) a[j] = arguments[j][i];
  }
  return result;
};

var letters = ['a', 'e', 'i', 'o', 'u'];
var values  = [12, 22, 7, 7, 3];
var valuesAndLetters = Array.zip(values,letters);
// [[12,"a"],[22,"e"],[7,"i"],[7,"o"],[3,"u"]]

var sorted = valuesAndLetters.sort(function(a,b){
  // Sort in descending order, first by value, then by letter
  return a[0]<b[0]?1:a[0]>b[0]?-1:a[1]<b[1]?1:a[1]>b[1]?-1:0;
});
// [[22,"e"],[12,"a"],[7,"o"],[7,"i"],[3,"u"]]

Answer 4

function odd_way_to_sort(intArr, charArr){
    var min = intArr[0]
    for(index in intArr){
        //some sort of sorting
        // where you save the indexes and then match them to corresponding char Arr indexes
    }
}

Answer 5

压缩方式是一种简单的方法，但为了完整性，另一种方法是使用索引数组：

var letterArray = ['a', 'e', 'i', 'o', 'u'];
var valueArray = [12, 22, 7, 7, 3];
var indexArray = [0, 1, 2, 3, 4]; // normally you would compute this dynamically
indexArray.sort(function(a, b) { return valueArray[a] - valueArray[b]; });

要检索按值顺序排序的字母数组，您需要遍历indexArray，检索每个索引处的字母。

Answer 6

如果我这样做，而不是使用两个数组，我会使用一个对象数组。然后你可以创建自己的排序比较函数，这将使你对数据结构有最大的控制。

letters_and_values = [{letter: 'a', value: 12},
                      {letter: 'e', value: 22},
                      {letter: 'i', value: 7},
                      {letter: 'o', value: 7},
                      {letter: 'u', value: 3}];

function valueCompare(obj1, obj2) {
    if (obj1.value < obj2.value) {
        return 1;
    }
    else if (obj1.value > obj2.value) {
        return -1;
    }
    else { 
        return 0;
    }
}

letters_and_values.sort(valueCompare);

// => [Object { letter="e", value=22}, 
//     Object { letter="a", value=12},
//     Object { letter="i", value=7}, 
//     Object { letter="o", value=7}, 
//     Object { letter="u", value=3}]

基于int数组的Javascript排序字符串数组

6 个答案: