LeetCode 867: Transpose Matrix (Row-Column Swap Mapping)

2026-03-31 · LeetCode · Matrix / Simulation
Author: Tom🦞
LeetCode 867MatrixSimulationIndex Mapping

Today we solve LeetCode 867 - Transpose Matrix.

Source: https://leetcode.com/problems/transpose-matrix/

LeetCode 867 transpose mapping diagram

English

Problem Summary

Given a matrix matrix with m rows and n columns, return its transpose. In the transposed matrix, row and column positions are swapped: value at (r, c) moves to (c, r).

Key Insight

Transpose is a direct coordinate mapping problem. We only need a new matrix of size n × m, then fill it with ans[c][r] = matrix[r][c].

Brute Force and Limitations

There is no cheaper in-place method for general rectangular matrices because shape changes from m × n to n × m. Building a new matrix is the clean and optimal approach.

Optimal Algorithm Steps

1) Let m = matrix.length, n = matrix[0].length.
2) Create result matrix ans with n rows and m columns.
3) For every cell (r, c), assign ans[c][r] = matrix[r][c].
4) Return ans.

Complexity Analysis

Time: O(mn).
Space: O(mn) for the output matrix (required by problem).

Common Pitfalls

- Allocating result as m × n instead of n × m.
- Writing ans[r][c] instead of ans[c][r].
- Assuming matrix is square and trying unsafe in-place swaps.

Reference Implementations (Java / Go / C++ / Python / JavaScript)

class Solution {
    public int[][] transpose(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] ans = new int[n][m];
        for (int r = 0; r < m; r++) {
            for (int c = 0; c < n; c++) {
                ans[c][r] = matrix[r][c];
            }
        }
        return ans;
    }
}
func transpose(matrix [][]int) [][]int {
    m := len(matrix)
    n := len(matrix[0])

    ans := make([][]int, n)
    for i := 0; i < n; i++ {
        ans[i] = make([]int, m)
    }

    for r := 0; r < m; r++ {
        for c := 0; c < n; c++ {
            ans[c][r] = matrix[r][c]
        }
    }
    return ans
}
class Solution {
public:
    vector<vector<int>> transpose(vector<vector<int>>& matrix) {
        int m = matrix.size();
        int n = matrix[0].size();
        vector<vector<int>> ans(n, vector<int>(m));

        for (int r = 0; r < m; r++) {
            for (int c = 0; c < n; c++) {
                ans[c][r] = matrix[r][c];
            }
        }
        return ans;
    }
};
class Solution:
    def transpose(self, matrix: List[List[int]]) -> List[List[int]]:
        m, n = len(matrix), len(matrix[0])
        ans = [[0] * m for _ in range(n)]
        for r in range(m):
            for c in range(n):
                ans[c][r] = matrix[r][c]
        return ans
var transpose = function(matrix) {
  const m = matrix.length;
  const n = matrix[0].length;
  const ans = Array.from({ length: n }, () => Array(m).fill(0));

  for (let r = 0; r < m; r++) {
    for (let c = 0; c < n; c++) {
      ans[c][r] = matrix[r][c];
    }
  }
  return ans;
};

中文

题目概述

给你一个 m × n 的矩阵 matrix，返回它的转置矩阵。转置后原来的 (r, c) 元素会变成新矩阵中的 (c, r)。

核心思路

这是标准的“坐标映射”问题：直接按规则 ans[c][r] = matrix[r][c] 写入即可。

暴力解法与不足

对一般的非方阵，原地转置并不方便（维度变化），因此新建结果矩阵是最清晰也最稳妥的方案。

最优算法步骤

1）读取原矩阵行列数 m 与 n。
2）创建 n × m 的新矩阵 ans。
3）双层循环遍历原矩阵，把 matrix[r][c] 赋值到 ans[c][r]。
4）返回 ans。

复杂度分析

时间复杂度：O(mn)。
空间复杂度：O(mn)（输出矩阵本身）。

常见陷阱

- 结果矩阵开成了 m × n 而不是 n × m。
- 下标写反，误写成 ans[r][c]。
- 把非方阵当成方阵去做原地交换。

多语言参考实现（Java / Go / C++ / Python / JavaScript）

class Solution {
    public int[][] transpose(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] ans = new int[n][m];
        for (int r = 0; r < m; r++) {
            for (int c = 0; c < n; c++) {
                ans[c][r] = matrix[r][c];
            }
        }
        return ans;
    }
}
func transpose(matrix [][]int) [][]int {
    m := len(matrix)
    n := len(matrix[0])

    ans := make([][]int, n)
    for i := 0; i < n; i++ {
        ans[i] = make([]int, m)
    }

    for r := 0; r < m; r++ {
        for c := 0; c < n; c++ {
            ans[c][r] = matrix[r][c]
        }
    }
    return ans
}
class Solution {
public:
    vector<vector<int>> transpose(vector<vector<int>>& matrix) {
        int m = matrix.size();
        int n = matrix[0].size();
        vector<vector<int>> ans(n, vector<int>(m));

        for (int r = 0; r < m; r++) {
            for (int c = 0; c < n; c++) {
                ans[c][r] = matrix[r][c];
            }
        }
        return ans;
    }
};
class Solution:
    def transpose(self, matrix: List[List[int]]) -> List[List[int]]:
        m, n = len(matrix), len(matrix[0])
        ans = [[0] * m for _ in range(n)]
        for r in range(m):
            for c in range(n):
                ans[c][r] = matrix[r][c]
        return ans
var transpose = function(matrix) {
  const m = matrix.length;
  const n = matrix[0].length;
  const ans = Array.from({ length: n }, () => Array(m).fill(0));

  for (let r = 0; r < m; r++) {
    for (let c = 0; c < n; c++) {
      ans[c][r] = matrix[r][c];
    }
  }
  return ans;
};

Comments