转置矩阵 图解题解

转置矩阵，到底要返回一个什么形状

给一个二维整数矩阵 matrix，把它转置后返回。转置就是行列对调：原来第 i 行第 j 列的数，跑到新矩阵第 j 行第 i 列。形状也跟着变，原矩阵 m 行 n 列，转置后就是 n 行 m 列。题面 matrix=[[1,2,3],[4,5,6],[7,8,9]] 这种方阵转置后是 [[1,4,7],[2,5,8],[3,6,9]]；而 2 行 3 列的矩阵转置后就成了 3 行 2 列，长宽掉个个儿。

想在原矩阵上就地对调，会卡在哪

一个直接的念头是不另开空间，就在原矩阵上把两个位置的数对调。方阵勉强行得通——沿主对角线，把第 i 行第 j 列和第 j 行第 i 列两两交换即可。可本题不保证是方阵：题面那个 2 行 3 列的矩阵转置后是 3 行 2 列，行数列数都变了，原来的格子装不下新形状，就地交换无处落脚。除非确定是方阵，否则老实另开新矩阵才稳妥。

行变列：第 i 行第 j 列的数该落到哪

转置的核心就一条对应关系：原矩阵第 i 行第 j 列的数，在新矩阵里落到第 j 行第 i 列，两个下标对调，即 ans[i][j] = matrix[j][i]。原矩阵横着的一行，转置后变成竖着的一列；一列则变成一行。Python 里一句 list(zip(*matrix)) 就够了：zip 把每一行同一位置的元素打包成一组，每组恰好是原矩阵的一列，正是转置。

新矩阵先开 n 行 m 列，再逐格搬数

落到实现上分两步。先量原矩阵尺寸：m 是行数，n 是列数，据此开一个 n 行 m 列的空矩阵 ans。然后两层循环逐格填：外层 i 走新矩阵的行、也就是原矩阵的列，内层 j 走新矩阵的列、也就是原矩阵的行，每格执行 ans[i][j] = matrix[j][i]，把对应的数各搬一次，不重不漏。

拿题面的 3×3 方阵亲手转一遍

用题面第一个例子 matrix=[[1,2,3],[4,5,6],[7,8,9]]。原矩阵第 0 行是 1、2、3，第 1 行是 4、5、6，第 2 行是 7、8、9。转置按列取：新矩阵第 0 行取原来的第 0 列，是 1、4、7；第 1 行取第 1 列，是 2、5、8；第 2 行取第 2 列，是 3、6、9，拼起来就是 [[1,4,7],[2,5,8],[3,6,9]]，正好是题面要的答案。主对角线上的 1、5、9 位置没动，它们的行下标和列下标本就相等；对角线外的数才真换了座，比如 2 从第 0 行第 1 列挪到了第 1 行第 0 列。

搬错一个下标，就等于原样抄了一遍

最易出错的是下标和形状。把 ans[i][j] = matrix[j][i] 里的下标忘了对调、写成 ans[i][j] = matrix[i][j]，等于把原矩阵原样抄一遍，压根没转置。形状开反也一样致命：新矩阵本该 n 行 m 列，若开成 m 行 n 列，碰上非方阵不是越界就是留空。复杂度上，矩阵里 m 乘 n 个数每个只经手一趟，时间 O(m·n)；新矩阵要存下全部数，空间 O(m·n)，不计返回结果则只用几个循环变量，是 O(1)。

Python

from __future__ import annotations
from typing import *
from collections import *
from functools import *
from itertools import *
from math import *
from heapq import *
from bisect import *
class Solution:
    def transpose(self, matrix: List[List[int]]) -> List[List[int]]:
        return list(zip(*matrix))

C++

#include <algorithm>
#include <array>
#include <cctype>
#include <climits>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
class Solution {
public:
    vector<vector<int>> transpose(vector<vector<int>>& matrix) {
        int m = matrix.size(), n = matrix[0].size();
        vector<vector<int>> ans(n, vector<int>(m));
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                ans[i][j] = matrix[j][i];
            }
        }
        return ans;
    }
};

Java

import java.util.*;
class Solution {
    public int[][] transpose(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        int[][] ans = new int[n][m];
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                ans[i][j] = matrix[j][i];
            }
        }
        return ans;
    }
}