Question

我试图用它的两个位置排序一个二维数组，第一个位置有更多的优先级。对于例如左边的数组是未排序的，右边是排序的答案。

[[1,2]                    [[0,9]
,[2,4]                    ,[1,1]
,[2,5]          ===>      ,[1,2]
,[1,1]                    ,[2,4]
,[0,9]]                   ,[2,5]]

使用arr.sort((a,b) => a[0] !== b[0] ? a[0] - b[0] : a[1] - b[1])轻松完成。但后来我想到了如何对三维数组进行排序。 ~~容易吗？只需添加另一个三元运算符。~~。（其实我的思维过程是错误的）。但是我如何对n维数组进行排序（当给出n时）。是否有可能在没有循环和递归的情况下回答这个问题（可以使用内置和原型函数，如forEach reduce等。）

编辑： - 三维数组： - （已经分类）

[
[[1,2],[1,2]],
[[3,4],[7,8]],
[[5,6],[21,3]]
]
                            [arr,arr,arr]
                      [arr,arr]___|___[arr,arr] 
              [1,2]___|___[1,2]   |    [3,4]__|__[7,8]
                                  |                              
                          [5,6]___|___[21,3]

（数组的族树）

编辑： - 答案可能包含递归或循环。我只是在问没有它们是否可以完成。

编辑： - 规则是除最外层数组外，所有其他数组只能包含两个可以是数字或另一个数组的元素。相应的元素不需要是相同的类型，但数字将比数组具有更多的值。如果两个相应的数字相等，则比较它们的右边数字。如果它们相等，那么将父数组与它的右侧数组/数字进行比较（无论它是什么）。

右手边的意思是后来的兄弟姐妹。（有一个共同的父阵列。（虽然不是祖父母））

未排序的数组示例

[        
[[21,5],[16,18]],
[[12,45],[15,23]],
[[12,45],[15,22]]
]
To sorted =>
[        
[[12,45],[15,22]],
[[12,45],[15,23]],
[[21,5],[16,18]]
]

Answer 1

您可以计算差异数组并找到第一个非零值：

arr.sort((arr1, arr2) => {
    let diff = arr1.map((el, index) => el - arr2[index]);
    return diff.find(el => el !== 0);
});

Answer 2

您可以使用每个级别的新属性对下一个更深层次的所有已排序项目对嵌套数组进行排序。

如果实际排序的数组没有嵌套数组，则按此值_排序或仅按给定元素排序。

var array = [[[21, 5], [18, 16]], [[12, 45], [15, 23]], [[12, 45], [15, 22]]];

array.sort(function sort(a, b) {
    var i = 0;
    if (Array.isArray(a) && Array.isArray(b)) {
        [a, b].forEach(function (c) {
            if (c._) {
                return;
            }
            c.sort(sort);
            c._ = c.reduce((r, d) => r.concat(d._ || d), []);
        });
        while (i < a._.length && i < b._.length && a._[i] === b._[i]) {
            i++;
        }
        return a._[i] - b._[i];
    }
    return a - b;
});

console.log(array);

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

Answer 3

只需遍历内部列表的最大长度，如果没有值，则为0：

function sortMulti(a, b) {
  for (var index = 0; index < Math.max(a.length, b.length); index++) {
    var A = (a[index] === void 0) ? 0 : a[index];
    var B = (b[index] === void 0) ? 0 : b[index];
    var cmp = B - A;
    if (cmp != 0) {
      return cmp;
    }
  }
  return 0;
}
//TEST
var lista = [
  [1, 20],
  [2, 4],
  [2, 5],
  [1, 1],
  [0, 9],
  [2, 2, 5],
  [1, 3]
];
var listb = [
  [0, 9],
  [1, 1],
  [1, 2],
  [2, 4],
  [2, 5]
];
var output = document.body.appendChild(document.createElement("pre"));
output.innerHTML = "Sorting multidimensionals:\nRAW:\nList a: [" + JSON.stringify(lista.join("],["), null, 1) + "]\nList b: [" + JSON.stringify(listb.join("],["), null, 1) + "]\nSORTED (biggest to smallest):\nList a: [" + JSON.stringify(lista.sort(sortMulti).join("],["), null, 1) + "]\nList b: [" + JSON.stringify(listb.sort(sortMulti).join("],["), null, 1) + "]";

编辑1 - 版本2.0

这是一个维护编辑到问题中的规则的版本：

function sortMulti(a, b) {
    for (var outerIndex = 0; outerIndex < Math.max(a.length, b.length); outerIndex++) {
        var A = (a[outerIndex] === void 0 ? [0, 0] : a[outerIndex]);
        var B = (b[outerIndex] === void 0 ? [0, 0] : b[outerIndex]);
        for (var innerIndex = 0; innerIndex < Math.max(A.length, B.length); innerIndex++) {
            var cmp = (A[innerIndex] === void 0 ? 0 : A[innerIndex] - B[innerIndex] === void 0 ? 0 : B[innerIndex]);
            if (cmp !== 0) {
                return cmp;
            }
        }
    }
    return 0;
}
//TEST
var list = [
    [[21, 5], [16, 18]],
    [[12, 45], [15, 23]],
    [[12, 45], [15, 22]]
];
var output = document.body.appendChild(document.createElement("pre"));
output.innerHTML = "RAW\n" + JSON.stringify(list.sort(sortMulti).map(function (a) { return JSON.stringify(a); }), null, 2) + "\nSORTED\n" + JSON.stringify(list.sort(sortMulti).map(function (a) { return JSON.stringify(a); }), null, 2) + "\n";

如何在javascript

3 个答案: