如何使用递归转置 m*n 矩阵？

Question

我正在尝试使用递归转置矩阵。现在，我知道在正常情况下这不是一个好主意，嵌套循环/嵌套映射或类似方法更好，但出于教育目的，我需要学习这一点。

为了表明我做了功课，这里是嵌套循环方法：

const arrMatrix = [
  [3, 6, 7, 34],
  [6, 3, 5, 2],
  [2, 6, 8, 3]
];

const transposedMatrix = []

for (let i = 0; i < arrMatrix[0].length; i++) {
  const tempCol = [];
  for (let j = 0; j < arrMatrix.length; j++) {
    tempCol.push(arrMatrix[j][i]);
  }
  transposedMatrix.push(tempCol);
}

console.log(transposedMatrix);

这是使用嵌套maps 的另一种方法：

    const arrMatrix = [
      [3, 6, 7, 34],
      [6, 3, 5, 2],
      [2, 6, 8, 3]
    ];

    const transposedMatrix = arrMatrix[0].map((_, i) =>
      arrMatrix.map((_, j) => arrMatrix[j][i])
    );

    console.log(transposedMatrix);

这里有 some resources 我经历过但没能想出使用它们的解决方案。

如果可能的话，除了算法/代码，请给我一些解释和资源，让我了解更多。

Answer 1

  const map = ([head, ...tail], mapper) => tail.length ? [mapper(head), ...map(tail, mapper)] : [mapper(head)];

  const transpose = matrix =>
    matrix[0].length 
      ? [map(matrix, row => row.shift()), ...transpose(matrix)]
      :  [];

工作原理：

从给定的矩阵中，我们总是取出第一列（matrix.map(row => row.shift())，然后我们继续递归：

 [[1, 1, 1],    ->   [[1, 1],    ->  [[1],   ->   [[],
  [2, 2, 2],          [2, 2],         [2],         [],
  [3, 3, 3]]          [3, 3]]         [3]]         []]

然后达到基本情况，矩阵为空（matrix[0].length 为 0 = falsy）并返回一个空数组。现在在每一步中，取出的列都会添加到该数组中，因此它现在是一行：

   [[1, 2, 3],    <-    [[1, 2, 3],    <-  [[1, 2, 3]]   <-  []
    [1, 2, 3],            [1, 2, 3]]    
    [1, 2, 3]]

---

注意：这会破坏原始数组。

Answer 2

const transpose = matrix => {
  const row = (x) => x >= matrix[0].length ? [] : [col(x, 0), ...row(x + 1)];
  const col = (x, y) => y >= matrix.length ? [] : [matrix[y][x], ...col(x, y + 1)];
  return row(0);
};

该版本不会改变原始数组。您可以更进一步，而不是 纯粹的功能性，但这有点矫枉过正：

 const transpose = matrix => (
   (row, col) => row(row)(col)(0)
 )(
    row => col => (x) => x >= matrix[0].length ? [] : [col(col)(x, 0), ...row(row)(col)(x + 1)],
    col => (x, y) => y >= matrix.length ? [] : [matrix[y][x], ...col(col)(x, y + 1)]
 );

Answer 3

这与 hitmands 的解决方案非常相似，并且可能性能较差，但我认为避免使用列索引会稍微干净一些：

const head = xs => xs[0]
const tail = xs => xs.slice(1)

const transpose = (m) => head(m).length
  ? [m.map(head), ...transpose(m.map(tail))]
  : []

const matrix = [
  [3, 6, 7, 34],
  [6, 3, 5, 2],
  [2, 6, 8, 3]
]

console .log (
  transpose (matrix)
)

此版本将第一列转置为一行（通过.map(head)），然后在剩余的矩阵上重复（通过.map(tail)），当第一行为空时触底。 如果您愿意，您可以内联这些辅助函数，使其看起来像这样：

const transpose = (m) => m[0].length
  ? [m.map(xs => xs[0]), ...transpose(m.map(xs => xs.slice(1)))]
  : []

..但我不会推荐它。第一个版本似乎更具可读性，head 和 tail 很容易重复使用。

更新

user633183 建议另一种转义条件。这是一个很好的问题，对于格式错误的数据，它是否是一个更好的结果，但它肯定是一个有用的可能变体：

const head = xs => xs[0]
const tail = xs => xs.slice(1)
const empty = xs => xs.length == 0

const transpose = (m) => m.some(empty)
  ? []
  : [m.map(head), ...transpose(m.map(tail))]

（这也可以用m.every(nonempty)通过反转条件表达式中的结果和替代来完成，但我认为它会稍微难以阅读。）

Answer 4

我会这样写， 假设矩阵内的所有行都具有相同的长度：

1. 检查是否还有要处理的行
2. 从给定索引处的每个列创建一行
3. 将列索引增加 1
4. 使用新索引调用转置

const transpose = (m, ci = 0) => ci >= m[0].length 
  ? [] 
  : [m.map(r => r[ci]), ...transpose(m, ci + 1)]
;


const matrix = [
  [3, 6, 7, 34],
  [6, 3, 5, 2],
  [2, 6, 8, 3]
];

console.log(
  transpose(matrix),
);

Answer 5

我有一个想法，使用 Maybe monad 编写 transpose。我将开始使用函数式操作，然后重构以清理代码 -

依赖关系 -

const { Just, Nothing } =
  require("data.maybe")

const safeHead = (a = []) =>
  a.length
    ? Just(a[0])
    : Nothing()

const tail = (a = []) =>
  a.slice(1)

没有重构 -

const column = (matrix = []) =>
  matrix.reduce
    ( (r, x) =>
        r.chain(a => safeHead(x).map(x => [ ...a, x ]))
    , Just([]) 
    )

const transpose = (matrix = []) =>
  column(matrix)
    .map(col =>
      [ col, ...transpose(matrix.map(tail)) ]
    )
    .getOrElse([])

使用通用 append 和 lift2 重构 column -

const append = (a = [], x) =>
  [ ...a, x ]

const lift2 = f =>
  (mx, my) =>
    mx.chain(x => my.map(y => f(x, y)))

const column = (matrix = []) =>
  matrix.reduce
    ( (r, x) =>
        lift2(append)(r, safeHead(x))
    , Just([])
    )

const transpose = (matrix = []) =>
  column(matrix)
    .map(col =>
      [ col, ...transpose(matrix.map(tail)) ]
    )
    .getOrElse([])

使用通用转换器 mapReduce 再次重构 column -

const mapReduce = (map, reduce) =>
  (r, x) => reduce(r, map(x))

const column = (matrix = []) =>
  matrix.reduce
    ( mapReduce(safeHead, lift2(append))
    , Just([]) 
    )

const transpose = (matrix = []) =>
  column(matrix)
    .map(col =>
      [ col, ...transpose(matrix.map(tail)) ]
    )
    .getOrElse([])

transpose 在每个重构步骤中保持不变。它产生以下输出 -

transpose
  ( [ [ 1, 2, 3, 4 ]
    , [ 5, 6, 7, 8 ]
    , [ 9, 10, 11, 12 ]
    ]
  )
  // [ [ 1, 5, 9 ]
  // , [ 2, 6, 10 ]
  // , [ 3, 7, 11 ]
  // , [ 4, 8, 12 ]
  // ]

transpose
  ( [ [ 1, 2, 3, 4 ]
    , [ 5 ]
    , [ 9, 10, 11, 12 ]
    ]
  )
  // [ [ 1, 5, 9 ] ]