按特定數組的順序排序其他數組？

Question

我有這種形式一堆陣列：

var myRows = [ 
    [{idx: 0, val: 90}, {idx: 1, val: 75}, {idx: 2, val: 35}], 
    [{idx: 0, val: 50}, {idx: 1, val: 17}, {idx: 2, val: 95}], 
    [{idx: 0, val: 10}, {idx: 1, val: 24}, {idx: 2, val: 80}] 
    // ... 
]; 

可以說，我想通過val第一行升序排序，所以就變成：

[{idx: 2, val: 35}, {idx: 1, val: 75}, {idx: 0, val: 90}] 

有沒有一種簡單的方法對剩餘的數組進行排序，以便它們的順序與排序的第一行的idx-順序匹配？

myArrays = [ 
    [{idx: 2, val: 35}, {idx: 1, val: 75}, {idx: 0, val: 90}] 
    , [{idx: 2, val: 95}, {idx: 1, val: 17}, {idx: 0, val: 50}] 
    , [{idx: 2, val: 80}, {idx: 1, val: 24}, {idx: 0, val: 10}] 
    // ... 
]; 

也許這甚至可能沒有idx屬性？

Answer 1

您可以使用sorting with map併爲所有項目應用映射。

該建議保存索引，對數組進行排序並將順序應用於所有其他數組。

// the array to be sorted 
 
var list = [[{ idx: 0, val: 90 }, { idx: 1, val: 75 }, { idx: 2, val: 35 }], [{ idx: 0, val: 50 }, { idx: 1, val: 17 }, { idx: 2, val: 95 }], [{ idx: 0, val: 10 }, { idx: 1, val: 24 }, { idx: 2, val: 80 }]]; 
 

 
// temporary array holds objects with position and sort-value 
 
var mapped = list[0].map(function (el, i) { 
 
    return { index: i, value: el.val }; 
 
}) 
 

 
// sorting the mapped array containing the reduced values 
 
mapped.sort(function (a, b) { 
 
    return a.value - b.value; 
 
}); 
 

 
// rearrange all items in list 
 
list.forEach(function (a, i, aa) { 
 
    aa[i] = mapped.map(function (el) { 
 
     return a[el.index]; 
 
    }); 
 
}); 
 

 
console.log(list);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 2

當你放下IDX屬性，你可以使用數組：

// Function copied from here: http://stackoverflow.com/a/36164530/5710637 
 
var transpose = m => m[0].map((x,i) => m.map(x => x[i])) 
 

 
var sortByRow = 0  
 
var myRows = [ 
 
    [90, 75, 35], 
 
    [50, 17, 95], 
 
    [10, 24, 80] 
 
] 
 
var myCols = transpose(myRows) 
 
myCols.sort((x, y) => x[sortByRow] - y[sortByRow]) 
 
myRows = transpose(myCols) 
 
console.log(myRows)

Answer 3

你可以做這樣的事情。

var order = myRows[0].map(function(e) { return e.idx }) 
myRows.forEach(function(row) { 
    row.sort(function(a,b) { 
     return order.indexOf(a.idx) - order.indexOf(b.idx); 
    }); 
}); 

這是非常簡單的代碼，只是爲了展示這個想法。 對於非常大的數組，它可能會很慢。

Answer 4

使用hash table創建基於第一行上的排序標準 - 看演示如下：

var myRows=[[{idx:0,val:90},{idx:1,val:75},{idx:2,val:35}],[{idx:0,val:50},{idx:1,val:17},{idx:2,val:95}],[{idx:0,val:10},{idx:1,val:24},{idx:2,val:80}]]; 
 

 
// sort the first row (as desired) 
 
myRows[0].sort((a,b) => a.val - b.val); 
 

 
myRows.forEach(function(c,i){ 
 
    if(i === 0){ 
 
     // create order criteria based on first row 
 
     c.forEach(function(e, k){ 
 
     this[e.idx] = k; 
 
     }); 
 
    } else { 
 
     c.sort(function(a,b) { 
 
     return this[a.idx] - this[b.idx]; 
 
     }); 
 
    } 
 
}, Object.create(null)); 
 
     
 
console.log(myRows);

.as-console-wrapper{top:0;max-height:100%!important;}

Answer 5

你可以做以下這呢，

• 排序陣列的第一行，和它們的idx ES存儲在臨時陣列
• 根據第一idx
• 排序與temp屬性分配剩餘的陣列其餘陣列基於他們的temp屬性（它基於第一個陣列）
• 刪除temp屬性

例如

var filteredRows = []; 
 
var myRows = [ 
 
    [{idx: 0, val: 90}, {idx: 1, val: 75}, {idx: 2, val: 35}], 
 
    [{idx: 0, val: 50}, {idx: 1, val: 17}, {idx: 2, val: 95}], 
 
    [{idx: 0, val: 10}, {idx: 1, val: 24}, {idx: 2, val: 80}] 
 
]; 
 

 
/* 1. Sort the first row */ 
 
myRows[0].sort(function(a, b) { 
 
    return a.val - b.val; 
 
}); 
 
filteredRows.push(myRows[0]); 
 

 
/* 2. Get indexes */ 
 
var idxs = []; 
 
for (var obj of myRows[0]) { 
 
    idxs.push(obj.idx); 
 
} 
 

 
/* Handle the remaining array */ 
 
myRows.slice(1).map(function (val) { 
 
    /* 3. Assign temp value */ 
 
    val.map(function (obj, i) { 
 
     obj.temp = idxs[i]; 
 
    }); 
 

 
    /* 4. Sort them */ 
 
    val.sort(function (a, b) { 
 
     return a.temp - b.temp; 
 
    }); 
 

 
    /* 5. Remove temp value */ 
 
    val.map(function (obj, i) { 
 
     delete obj.temp; 
 
    }); 
 
}); 
 

 
console.log(JSON.stringify(myRows));