Easy

题目描述

给你一个二维整数数组 matrix，返回 matrix 的 转置矩阵。

矩阵的 转置 是指将矩阵沿着主对角线翻转，交换矩阵的行索引与列索引。

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[1,4,7],[2,5,8],[3,6,9]]

示例 2：

输入：matrix = [[1,2,3],[4,5,6]]
输出：[[1,4],[2,5],[3,6]]

提示：

  • m == matrix.length
  • n == matrix[i].length
  • 1 <= m, n <= 1000
  • 1 <= m * n <= 10^5
  • -10^9 <= matrix[i][j] <= 10^9

解题思路

解题思路

这是一道典型的矩阵转置题目。矩阵转置的核心概念是：行变列，列变行。

具体来说，对于原矩阵 matrix[i][j]，转置后的矩阵中对应位置应该是 transposed[j][i]。

方法一：直接构造新矩阵（推荐）

最直观的方法是创建一个新的矩阵来存储转置结果：

  1. 如果原矩阵是 m × n，转置后应该是 n × m
  2. 遍历原矩阵的每个元素 matrix[i][j]
  3. 将其放到新矩阵的 [j][i] 位置

方法二：原地转置（仅适用于方阵）

对于方形矩阵（m = n），可以通过交换对角元素实现原地转置，但由于题目中矩阵可能不是方阵，此方法不适用。

方法三：使用内置函数

在某些语言中可以利用内置的矩阵操作函数，如 Python 的 zip 函数，代码更简洁。

时间复杂度：O(m × n)，需要遍历整个矩阵 空间复杂度：O(m × n)，需要创建新的转置矩阵

代码实现

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

class Solution:
    def transpose(self, matrix: List[List[int]]) -> List[List[int]]:
        m, n = len(matrix), len(matrix[0])
        
        result = [[0] * m for _ in range(n)]
        
        for i in range(m):
            for j in range(n):
                result[j][i] = matrix[i][j]
        
        return result

public class Solution {
    public int[][] Transpose(int[][] matrix) {
        int m = matrix.Length;
        int n = matrix[0].Length;
        
        int[][] result = new int[n][];
        for (int i = 0; i < n; i++) {
            result[i] = new int[m];
        }
        
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                result[j][i] = matrix[i][j];
            }
        }
        
        return result;
    }
}

var transpose = function(matrix) {
    const m = matrix.length;
    const n = matrix[0].length;
    
    const result = Array(n).fill().map(() => Array(m));
    
    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            result[j][i] = matrix[i][j];
        }
    }
    
    return result;
};
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度分析
时间复杂度O(m × n) - 需要遍历原矩阵的每个元素
空间复杂度O(m × n) - 需要创建转置矩阵存储结果