有一些类似的帖子在敲门，但我找不到能完全解决这个特定问题的任何东西...... 我有两个配对值数组：
var A=[0.5, 0.6, 0.5, 0.7, 0.8, 0.1]
var B=['a','b','c','d','e','f']
//note: a=0.5, b=0.6, c=0.5, d=0.7, etc
对数组进行排序以使数组 A 以数字升序排列并保持数据结构的最适合处理器的方法是什么？我猜内置 array.sort(function) 会最快，但我对语法没有信心。
【问题讨论】：
标签： javascript arrays
有点老套，但确实有效。
var A = [0.5, 0.6, 0.5, 0.7, 0.8, 0.1];
var B = ['a', 'b', 'c', 'd', 'e', 'f'];
var all = [];
for (var i = 0; i < B.length; i++) {
all.push({ 'A': A[i], 'B': B[i] });
}
all.sort(function(a, b) {
return a.A - b.A;
});
A = [];
B = [];
for (var i = 0; i < all.length; i++) {
A.push(all[i].A);
B.push(all[i].B);
}
console.log(A, B);
0.1, 0.5, 0.5, 0.6, 0.7, 0.8
["f", "a", "c", "b", "d", "e"]
基本上，我们在一个新数组中创建具有A 和B 之间明确联系的对象，然后sort() 这样做。
那我回去重建原来的两个数组。
Már Örlygsson 在 cmets 中提出了一个很好的观点。他建议不要生成像 {A: 0.5, B: 'a'} 这样的对象，而是将 A 和 B 值放在像 [0.5, 'a'] 这样的数组中。
这个应该更快，但如果需要调试all 数组，它的可读性会稍差。如果您遇到性能问题，我将由您决定，请分析这两种方法并选择最快的方法。
【讨论】：
output 部分中。
all.push( [ A[i], B[i] ] ) 填充all，然后用a[0] - b[0] 进行排序可能会快一些，并且使用更少的内存，尤其是当A 和B 变得更大时。跨度>
我注意到上述所有解决方案都使用了地图。另一种节省一点内存的方法是创建一个索引数组，根据 A 对索引进行排序，然后根据索引重构 A 和 B。
var A=[0.5, 0.6, 0.5, 0.7, 0.8, 0.1];
var B=['a','b','c','d','e','f'];
var indices = A.map(function(elem, index){return index;}); //an array of indices
indices.sort(function (a,b) {return A[a] - A[b];});
//print out the results
for (var i = 0; i < A.length; i++)
document.body.innerHTML += 'A: ' + A[indices[i]] + ', B: ' + B[indices[i]] + '<br>';
这是jsfiddle
编辑：受chowey's comment 启发的半单行：
var BSorted = A.map(function(e,i){return i;})
.sort(function(a,b){return A[a] - A[b];})
.map(function(e){return B[e];});
【讨论】：
A = A.map(function(v,i,A){return A[indices[i]]}).
indices.map(function(i){return B[i];}); 更简单一些。使用它，您实际上可以将整个事情链接到var BSorted = A.map(function(e,i){return i;}).sort(function(a,b){return A[a] - A[b];}).map(function(e){return B[e];});
如果你有一个带有元组的数组而不是两个数组，那会简单得多。因为那样你就可以使用内置的Array.sort()。
var arr = [{a: 0.5, b: 'a'}, {a: 0.6, b: 'b'}, {a: 0.5, b: 'c'}, ... ];
在这之后你可以写：
arr.sort(function(x,y) { return x.a - y.a });
【讨论】：
[ A[i], B[i] ]) 填充 arr 数组而不是对象可能会更快，内存效率更高。
Array.prototype.swap=function(a, b)
{
var tmp=this[a];
this[a]=this[b];
this[b]=tmp;
}
function partition(array, array2, begin, end, pivot)
{
var piv=array[pivot];
array.swap(pivot, end-1);
array2.swap(pivot, end-1);
var store=begin;
var ix;
for(ix=begin; ix<end-1; ++ix) {
if(array[ix]<=piv) {
array.swap(store, ix);
array2.swap(store, ix);
++store;
}
}
array.swap(end-1, store);
array2.swap(end-1, store);
return store;
}
function qsort(array, array2, begin, end)
{
if(end-1>begin) {
var pivot=begin+Math.floor(Math.random()*(end-begin));
pivot=partition(array, array2, begin, end, pivot);
qsort(array, array2, begin, pivot);
qsort(array, array2, pivot+1, end);
}
}
数组用于数字， array2 用于字符串， 它们的长度必须相同。
这是快速排序，所以时间是 O(N LogN)
来源是literateprograms.org，许可证是MIT，修改以管理我制作的第二个数组
【讨论】：
对于任何排序算法，都需要在算法时间和其他约束（通常是内存）之间进行权衡。您可能想看看Quicksort 和Bubble Sort，这是两种常见且非常快速的排序算法。你需要做一些小的修改，因为你实际上是在对两个数组进行排序，第一个是要排序的数据源 - 但这种改变是微不足道的。
编辑：注意，array.sort() 对您不起作用，因为您希望 arr1 中的更改反映在 arr2 中。你得自己写排序函数
【讨论】：
之前把两个数组放在一起 排序是最简单的方法。
var a1, b1, A= [0.5, 0.6, 0.5, 0.7, 0.8, 0.1],
B= ['a', 'b', 'c', 'd', 'e', 'f'],
ab= A.map(function(itm, i){ return [itm, i]; });
ab.sort(function(a, b){ return a[0]-b[0]; });
B= ab.map(function(itm){
A.push(itm[0]);
return B[itm[1]];
});
A= A.splice(B.length);
alert(A+'\n'+B)
/* returned value: (String)
0.1, 0.5, 0.5, 0.6, 0.7, 0.8
f, a, c, b, d, e
*/
【讨论】：
如果可能的话，你可能会更好地实际制作一个数据结构。这样，您可以在保持结构的同时基于一个属性对$A[] 进行排序。我没有做过任何速度测试或其他任何事情，但可能是......
A[0]['label']='a';
A[0]['value']=0.5;
A[1]['label']='b';
A[1]['value']=0.6;
A[2]['label']='c';
A[2]['value']=0.5;
A[3]['label']='d';
A[3]['value']=0.7;
A[4]['label']='e';
A[4]['value']=0.8;
A[5]['label']='f';
A[5]['value']=0.1;
【讨论】：
document.layers 对象。