Javascript 生成确定排序秩的JS数组

使用复杂数组（对于以列和行显示的表格数据的用例）可以说我有一些值：

var values = [
    [234, 386, 21, 38],
    [-23, 58, 106, 0],
    [45, -48, 506, 23],
    [109, 168, 42, 111]
];

返回匹配数组的最佳方法是什么？该数组将值按照正确（保持）的顺序与它们的列进行排序？在这种情况下，排序顺序是从高到低

例如，最终结果数组为：

[
    [1, 1, 4, 2],
    [4, 3, 2, 4],
    [3, 4, 1, 3],
    [2, 2, 3, 1]
];

请注意结果是如何按列垂直排序的

我希望将其用于大型数据集，因此任何关于最快性能的指导/提示都是我的目标

--

对于上下文：我的第一次尝试是用索引值映射原始数组，但我不确定从哪里开始：

var singleColumn = [234, -23, 45, 109];
for (var i = 0; i < singleColumn.length; i++) {
    singleColumn[i] = [singleColumn[i], i];
}

var singleColumn=[234，-23,45,109]；
对于（var i=0；i

本质上，技巧是在排序后保留原始索引。我首先将它们迭代到数据结构中，对其进行排序，然后根据结果重建二维数组结构

我没有做任何检查来确保输入的格式正确，假设所有行的宽度都与第一行相同

可能可以进行的优化是在排序期间将原始值转换为数据结构，这将消除数组的传递。我不认为有一种简单的方法可以做到这一点而不失去一些简洁性和可读性，这将是一个相当小的收获

var值=[
[234, 386, 21, 38],
[-23, 58, 106, 0],
[45, -48, 506, 23],
[109, 168, 42, 111]
];
功能等级（arr）{
var结果=[]；
对于（var col=0；coldocument.write（JSON.stringify（buildRanking（values））.split（']，['））.join（']，
['））；

本质上，技巧是在排序后保留原始索引。我首先将它们迭代到数据结构中，对其进行排序，然后根据结果重建二维数组结构

我没有做任何检查来确保输入的格式正确，假设所有行的宽度都与第一行相同

可能可以进行的优化是在排序期间将原始值转换为数据结构，这将消除数组的传递。我不认为有一种简单的方法可以做到这一点而不损失一些简洁性和可读性，这将是一个非常小的收获

var值=[
[234, 386, 21, 38],
[-23, 58, 106, 0],
[45, -48, 506, 23],
[109, 168, 42, 111]
];
功能等级（arr）{
var结果=[]；
对于（var col=0；coldocument.write（JSON.stringify（buildRanking（values））.split（']，['））.join（']，
['））；

这是一个非常不优化的第一步，但这里有一个松散的实现，我一步一步地做

function sort(rows) {

  var columns = [];

   /* Invert rows and columns */

  for (var i = 0, row; i < rows.length; i++) {
    row = rows[i];
    for (var j = 0, col; j < row.length; j++) {
      col = rows[i][j];
      columns[j] = columns[j] || [];
      columns[j][i] = col;
    }
  }

  /* Sort by descending order, returning index */

  var sortedColumns = columns.slice(0).map(function(column, i) {
    return column.slice(0).sort(function(a, b) {
      return b - a;
    }).map(function(value, j, sortedColumn) {
      return sortedColumn.indexOf(column[j]) + 1;
    });
  });


  /* Invert rows and columns back again */

  var sortedRows = [];

    for (var i = 0, row; i < sortedColumns.length; i++) {
    row = sortedColumns[i];
    for (var j = 0, col; j < row.length; j++) {
      col = sortedColumns[i][j];
      sortedRows[j] = sortedRows[j] || [];
      sortedRows[j][i] = col;
    }
  }

  return sortedRows;
}

var values = [
  [234, 386, 21, 38],
  [-23, 58, 106, 0],
  [45, -48, 506, 23],
  [109, 168, 42, 111]
];

var expected = [
  [1, 1, 4, 2],
  [4, 3, 2, 4],
  [3, 4, 1, 3],
  [2, 2, 3, 1]
];

var sorted = sort(values);

console.log(sorted.toString() === expected.toString()); // true

函数排序（行）{
var列=[]；
/*颠倒行和列*/
对于（变量i=0，行；i