Javascript 在2D数组和元素排序中更改迭代方向时的不可预测行为

假设我有一个2D数组：

┌─────────┬───┬───┬───┐
│ (index) │ 0 │ 1 │ 2 │
├─────────┼───┼───┼───┤
│    0    │ 2 │ 3 │ 2 │
│    1    │ 3 │ 1 │ 3 │
│    2    │ 2 │ 2 │ 3 │
└─────────┴───┴───┴───┘

我想对2D数组中的元素进行排序，并将它们按照从上到下的方向排列，如下所示：

┌─────────┬───┬───┬───┐
│ (index) │ 0 │ 1 │ 2 │
├─────────┼───┼───┼───┤
│    0    │ 1 │ 2 │ 3 │
│    1    │ 2 │ 2 │ 3 │
│    2    │ 2 │ 3 │ 3 │
└─────────┴───┴───┴───┘

┌─────────┬────┬────┬────┬────┬────┐
│ (index) │ 0  │ 1  │ 2  │ 3  │ 4  │
├─────────┼────┼────┼────┼────┼────┤
│    0    │ 30 │ 30 │ 30 │ 30 │ 30 │
│    1    │ 30 │ 30 │ 30 │ 30 │ 30 │
│    2    │ 30 │ 30 │ 30 │ 30 │ 30 │
│    3    │ 30 │ 30 │ 30 │ 30 │ 30 │
│    4    │ 30 │ 30 │ 30 │ 30 │ 30 │
└─────────┴────┴────┴────┴────┴────┘

到目前为止，我有这样一个代码：

const generateArray = (size, min, max) =>
    Array(size)
    .fill(0)
    .map(() => generateNumber(min, max));

const generateArray2D = (rows, cols, min, max) =>
    Array(rows)
    .fill(0)
    .map(() => generateArray(cols, min, max));

const generateNumber = (min, max) =>
    Math.floor(Math.random() * (max - min + 1)) + Math.floor(min);

const generated2DArray = generateArray2D(
    rows,
    cols,
    10,
    30
);

const sortedArray = [...generated2DArray].flat(1).sort(((a, b) => a - b))

for (const sortedElement of sortedArray) {
  for (let j = 0; j < generated2DArray.length; j++) {
    for (let i = 0; i < generated2DArray[j].length; i++) {
      generated2DArray[i][j] = sortedElement;
    }
  }
}

我尝试了两种选择，但我看不出问题的潜在原因。

---

提前感谢您对如何解决上述问题的建议。

第一次通过外循环，两个内循环将结果数组的所有元素设置为

sortedArray[0]

。第二次，它会将所有这些设置为

sortedArray[1]

，依此类推。每次通过外循环时，您都将整个

generated2DArray

设置为相同的值

不要使用外部循环，只需在2D数组中循环索引，并在1D数组中增加索引，而无需另一个循环

  k = 0;
  for (let j = 0; j < generated2DArray.length; j++) {
    for (let i = 0; i < generated2DArray[j].length; i++) {
      generated2DArray[i][j] = sortedArray[k++];
    }
  }

k=0；
for（设j=0；j

问题是，对于排序平面数组中的每个项目，您都在整个网格上循环

尝试删除外部循环并确定二维阵列中的位置，如下所示：

for (let j = 0; j < generated2DArray.length; j++) {
    for (let i = 0; i < generated2DArray[j].length; i++) {
        generated2DArray[i][j] = sortedArray[i*generated2DArray.length+j];
    }
}

for（设j=0；j

您可以根据排序数组中当前元素的索引计算当前行和列的索引，并根据这两个值更改输出数组的值

const generatarray=（大小、最小值、最大值）=>
数组（大小）
.fill（0）
.map（（）=>generateNumber（最小值，最大值））；
const generatarray2D=（行、列、最小值、最大值）=>
数组（行）
.fill（0）
.map（（）=>generatarray（cols，min，max））；
const generateNumber=（最小值，最大值）=>
Math.floor（Math.random（）*（max-min+1））+Math.floor（min）；
常量行=3
常数cols=4
const generated2DArray=generatarray2d（行、列、10、30）；
常量sortedArray=[…generated2DArray].flat（1）.排序（（a，b）=>a-b））
为了（让我进来，Darray）{
常数列=数学楼层（i/行）
常量行=i-（列*行）
生成的2darray[row][col]=sorteddarray[i]
}
for（让一个生成的2darray）{
log（JSON.stringify（a））
}