顺时针旋转矩阵全解析：从坐标映射到原地旋转

最近有朋友跑来问我，说在刷题时碰到“顺时针旋转矩阵”这道题，网上一搜题解一大把，但要么是直接给代码让人背，要么讲得云里雾里，看完还是不明白为什么这么写。这题确实很经典，LeetCode上叫“旋转图像”，面试出现频率极高，但很多人只是背下了解法，没搞懂背后的“模拟”思路到底是怎么来的。

其实“顺时针旋转矩阵”本质上是模拟题里非常典型的一类：规则清晰、实现细节多、边界条件容易踩坑。如果你能彻底吃透这道题，不只是会背代码，而是理解它背后的“模拟思维”，那以后再遇到螺旋矩阵、矩阵逆时针旋转、原地转置这类问题，基本都能举一反三。

这篇文章我就从这道题出发，把完整的思考链路、几种典型解法、为什么某些解法看着巧妙但容易写错、以及如何把“模拟”的思路迁移到其他场景，一次性讲透。不管你是在刷题准备面试，还是工作中遇到矩阵变换需求，这篇都值得认真读完。

1. 问题定位：这个经典题到底在考什么

先明确题目本身。输入是一个 n x n 的二维矩阵，要求将它顺时针旋转90度，而且必须在原地修改，不能额外开一个等大小的矩阵来存结果。

以 3x3 矩阵为例：

code复制1 2 3
4 5 6
7 8 9

顺时针旋转90度后变成：

code复制7 4 1
8 5 2
9 6 3

很快能看出规律：原矩阵第 0 行变成了新矩阵的第 n-1 列，原矩阵第 1 行变成了新矩阵的第 n-2 列，以此类推。用坐标表达就是：(i, j) 位置的元素，会移动到 (j, n-1-i) 位置。

这个题的考点非常多，逐个拆开看：

1.1 考的是“会不会建立坐标映射”

这是最核心的一层。很多人第一次做这题，能凭直觉写出 res[j][n-1-i] = matrix[i][j]，这说明你理解了旋转的本质是“坐标映射”。但面试官紧接着会问：如果不能用额外矩阵呢？这时候很多人就卡住了。

1.2 考的是“原地操作的循环覆盖逻辑”

原地旋转，意味着你不能把元素搬到新矩阵再搬回来，而是要在当前矩阵上通过连续交换完成旋转。本质上是一次“循环移位”：a -> b -> c -> d -> a，四个位置轮着覆盖。问题在于：哪些元素是一组的？每组的起始位置怎么确定？外层循环和内层循环的边界到底怎么算？

1.3 考的是边界条件的敏感度

n 是奇数、n 是偶数，处理范围是否不同？外层处理多少圈？每一圈内要处理多少个元素？这些细节如果没想清楚，写出来的代码几乎必然有 bug。

1.4 考的是不同解法之间的思维切换

同一种问题，至少有三类常见解法：新矩阵映射、原地四元素交换、先转置再翻转。这三种解法的时间和空间复杂度不同，代码量也不同，面试时你选哪种、为什么选这种，本身就是面试官观察你工程判断力的窗口。

所以这道题绝不是“背一个解法”这么简单。接下来我会按“从朴素到最优”的顺序展开，每一步都会说清楚“为什么”。

2. 为什么“老老实实模拟”不是好解法：初版朴素思路与性能瓶颈

遇到“顺时针旋转矩阵”，很多人的第一反应是：开一个新矩阵，把每个元素映射过去。这个思路完全正确，代码也很简短：

python复制def rotate(matrix):
    n = len(matrix)
    res = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            res[j][n-1-i] = matrix[i][j]
    return res

如果题目没限制空间，这个写法完全没问题，正确性一目了然。但 LeetCode 原题明确要求“原地旋转”，所以必须另想办法。

2.1 朴素方法的时间复杂度其实已经最优

先说明一点：任何解法的时间复杂度都不可能低于 O(n^2)，因为 n x n 矩阵里的每个元素都必须被移动到目标位置，这是理论下界。所以朴素方法的 O(n^2) 时间复杂度没有任何问题。

问题出在空间上。额外开一个 n x n 矩阵，空间复杂度是 O(n^2)。当 n 很小的时候无所谓，但到了 n = 1000 甚至更大，多出来的内存就是 10^6 量级的整数存储，在某些嵌入式场景或内存受限环境里，这不可接受。

2.2 朴素的“值交换”思路为什么能省掉新矩阵

原地旋转的核心思路是：旋转操作实际上是把元素分成若干个“环”，每个环内做循环移位。

以 4x4 矩阵为例：

code复制1  2  3  4
5  6  7  8
9  10 11 12
13 14 15 16

最外层的环是：

code复制1  2  3  4
5        8
9        12
13 14 15 16

顺时针旋转90度后，这个环上的元素会怎么走？看几个关键位置：

• 1 应该去 4 的位置
• 4 应该去 16 的位置
• 16 应该去 13 的位置
• 13 应该去 1 的位置

这四个位置形成一个闭环：(0,0) -> (0,n-1) -> (n-1,n-1) -> (n-1,0) -> (0,0)。

再看另一组：

• 2 应该去 8 的位置
• 8 应该去 15 的位置
• 15 应该去 9 的位置
• 9 应该去 2 的位置

四元素一组，轮换着覆盖。只要把每组的四个元素按顺序交换，就能完成整圈的旋转，而且不需要额外矩阵。

2.3 朴素思路落地时最容易踩的坑

这里有个特别容易犯的错：用临时变量保存值时，覆盖顺序搞反。

很多人会写类似这样的逻辑：

python复制temp = matrix[i][j]
matrix[i][j] = matrix[n-1-j][i]       # 错误：这不是 (i,j) 的逆映射
matrix[n-1-j][i] = matrix[n-1-i][n-1-j]
# ... 越写越乱

为什么乱？因为你必须明确每个位置的“来源”和“去向”。正确做法是沿着环的逆方向做覆盖：先把目标位置的值存起来，再把当前位置的值赋过去。

四元素一组的标准写法：

python复制temp = matrix[i][j]
matrix[i][j] = matrix[n-1-j][i]
matrix[n-1-j][i] = matrix[n-1-i][n-1-j]
matrix[n-1-i][n-1-j] = matrix[j][n-1-i]
matrix[j][n-1-i] = temp

这段代码的含义是：先保存左上角的值，然后左下角覆盖左上角，右下角覆盖左下角，右上角覆盖右下角，最后把保存的值放到右上角。方向是逆时针回填，但整体效果是顺时针旋转。

2.4 边界推导：为什么外循环是 n//2，内循环是 (n+1)//2

这是整个算法最细节的部分，也是面试时最容易懵的地方。

看外层：每处理完一圈，圈子就往内缩一层。n x n 矩阵一共需要处理 n // 2 圈。比如 4x4 处理 2 圈，5x5 处理 2 圈（最中间那个元素不用动，因为它旋转后还在原位）。

看内层：每一圈内，并不是处理一整条边上的所有元素，而要少处理一个，因为四个角已经在交换中覆盖到了。对于从 i 开始的第 i 圈，边长是 n - 2*i，需要遍历的元素数量是 边长 - 1，也就是 n - 2*i - 1。

用坐标表达：外层循环 i 从 0 到 n//2 - 1，内层循环 j 从 i 到 n-1-i（不含最后一个），范围长度正好是 n - 2*i - 1。

很多题解写 j 从 i 到 n-i-1，看起来是左闭右开，实际上因为 Python 的 range 是左闭右开，所以写 range(i, n-1-i) 才是正确的——这地方差一个元素就会导致每圈最后那个元素重复处理或者漏处理，结果整个矩阵错乱。

提示：如果 n 是奇数，最中心的元素不需要参与任何交换，它在旋转前后都留在 (n//2, n//2)，所以外循环取 n//2 自然就跳过了它。

2.5 完整代码与验证

python复制def rotate(matrix):
    n = len(matrix)
    for i in range(n // 2):
        for j in range(i, n - 1 - i):
            temp = matrix[i][j]
            matrix[i][j] = matrix[n - 1 - j][i]
            matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j]
            matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i]
            matrix[j][n - 1 - i] = temp
    return matrix

验证 4x4：

code复制初始：
1  2  3  4
5  6  7  8
9  10 11 12
13 14 15 16

旋转后：
13 9  5  1
14 10 6  2
15 11 7  3
16 12 8  4

逐个检查：(0,0) 的 1 去了 (0,3)，原来 (0,3) 的 4 去了 (3,3)，原来 (3,3) 的 16 去了 (3,0)，原来 (3,0) 的 13 回到 (0,0)。四元素闭环完成，正确。

这种解法的空间复杂度降到了 O(1)，时间复杂度仍然是 O(n^2)，性能上已经达到理论最优。

3. 原地旋转：四元素循环替换的底层逻辑

前一部分给出了标准原地旋转的代码，但只说了怎么写，没细说为什么要这么设计。这一部分我从数学映射的角度，把“四元素替换”背后的逻辑彻底拆开，帮你做到“闭着眼也能推出来”，而不是靠背代码。

3.1 坐标映射的本质：二维旋转矩阵

顺时针旋转90度，在坐标系里就是点 (x, y) 映射到 (y, -x)。如果把矩阵看成坐标系，行号是 y，列号是 x，旋转后的行号变成了原来的列号，旋转后的列号变成了 n-1-原来的行号。

写成公式：

code复制new_i = j
new_j = n - 1 - i

这个公式就是 (i, j) -> (j, n-1-i)。

但原地操作时，你无法直接赋值，因为 (j, n-1-i) 那个位置可能已经被之前的操作覆盖。所以必须用“临时变量 + 逆序覆盖”的方式。

3.2 四个位置的推导：从起点出发循环走一圈

固定某个起点 (i, j)，它要去的位置是 (j, n-1-i)。接着，(j, n-1-i) 这个位置的原主人要去哪？继续套公式：

code复制(j, n-1-i) -> (n-1-i, n-1-j)

再套：

code复制(n-1-i, n-1-j) -> (n-1-j, i)

再套：

code复制(n-1-j, i) -> (i, j)

发现又回到了起点。所以这四个位置天然构成一个闭环，只要在这个环上做轮换，就能完成旋转。

这就是为什么代码里是四行赋值加上一个 temp，而不是两两交换。理解了这个环，你甚至在写代码前就能推导出每个交换的具体坐标，不用靠记忆。

3.3 从“环”的角度理解为什么不用处理所有元素

很多人会问：既然是四个一组轮换，那是不是所有元素都要轮一次？答案是否定的。

原因很微妙：你每处理一个闭环，就相当于把四个元素一次性送到了正确位置。如果对每个元素都执行一次四元素交换，等于同一个闭环被重复处理了四次，结果矩阵会回到原样。

所以关键是“每个闭环只处理一次”。正因为如此，外层循环不能遍历全部行列，而要把范围限制在“每圈的前半段”：

• 每一圈，从左上角开始，沿第一行向右走，走到“倒数第二个元素”为止，每个元素作为闭环起点。
• 对于第 i 圈，起点集合是 (i, i), (i, i+1), ..., (i, n-2-i)。
• 内层循环 j 从 i 到 n-2-i，一共 n-2*i-1 个闭环。

如果你把 j 的范围写成 range(i, n-1-i)，在 Python 里正好是闭区间 [i, n-2-i]，是正确的。

3.4 奇数 n 和偶数 n 的差异

偶数 n，比如 4，外圈处理完后还有内圈（大小为 2x2），内圈的闭环起点只有 (1,1) 一个元素，处理完就完成了。外循环 i=0,1 各处理一圈。

奇数 n，比如 5，外圈处理完后，内圈是 3x3，再处理一圈后，最中间剩下 1x1，这一个元素不需要处理。外循环 i=0,1，n//2 = 2，正好。

如果你把外循环写成 range(n)，那处理到后面就会重复交换已经就位的元素，结果矩阵会被转回去，整个逻辑就崩了。

3.5 验证一个完整的 3x3 例子

手动执行一遍，确保逻辑完全对得上。初始矩阵：

code复制1 2 3
4 5 6
7 8 9

n=3。外循环 i=0，内层循环 j 从 0 到 n-2-0 = 1，即 j=0 和 j=1。

处理 (0,0)，值为 1：

• (0,0) <- (2,0)，值为 7
• (2,0) <- (2,2)，值为 9
• (2,2) <- (0,2)，值为 3
• (0,2) <- 1

现在矩阵：

code复制7 2 1
4 5 6
9 8 3

处理 (0,1)，值为 2：

• (0,1) <- (1,0)，值为 4
• (1,0) <- (2,1)，值为 8
• (2,1) <- (1,2)，值为 6
• (1,2) <- 2

最终矩阵：

code复制7 4 1
8 5 2
9 6 3

和题目要求完全一致。每一步的覆盖方向都是“逆时针取数、顺时针旋转”，逻辑闭环。

4. 翻转法的思维跳跃：为什么能省掉临时变量

四元素交换虽然已经 O(1) 空间，但代码写起来还是有点绕，面试时如果紧张容易写错。还有一种更优雅的解法：先沿主对角线转置，再左右翻转（或者先上下翻转，再转置），两步就能得到结果。这个方法不需要复杂的四元素环，代码更简洁，也更容易解释清楚。

4.1 转置 + 左右翻转的推导过程

先看转置的效果。转置是让 (i, j) 与 (j, i) 交换，也就是行列互换：

code复制1 2 3      1 4 7
4 5 6  ->  2 5 8
7 8 9      3 6 9

转置后的矩阵，再左右翻转（每行逆序）：

code复制1 4 7      7 4 1
2 5 8  ->  8 5 2
3 6 9      9 6 3

得到的结果正是顺时针旋转90度后的矩阵。

4.2 这两种操作叠加起来为什么等于旋转

从坐标映射的角度看：

• 转置：(i, j) -> (j, i)
• 左右翻转：(i, j) -> (i, n-1-j)

两步叠加：(i, j) -> (j, i) -> (j, n-1-i)。

这和顺时针旋转90度的目标映射 (i, j) -> (j, n-1-i) 完全一样。

如果你反过来，先上下翻转再转置，效果也一样。上下翻转：(i, j) -> (n-1-i, j)，再转置：(n-1-i, j) -> (j, n-1-i)，殊途同归。

4.3 翻转法的代码实现

转置的循环范围是上三角，避免重复交换。左右翻转就是每行用双指针逆序。

python复制def rotate(matrix):
    n = len(matrix)
    # 转置
    for i in range(n):
        for j in range(i+1, n):
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
    # 左右翻转
    for i in range(n):
        for j in range(n // 2):
            matrix[i][j], matrix[i][n-1-j] = matrix[i][n-1-j], matrix[i][j]

这段代码好写在哪？你不需要记四元素环的坐标变换，只需要记住“先转置、再左右翻转”这个口诀。而且每一步的意图都很清晰，写错了也容易排查。

4.4 翻转法的边界情况，一个坑都别踩

转置时内层循环从 i+1 开始，不是为了省事，而是为了避免重复交换。如果从 0 开始，(0,1) 交换后，等循环到 (1,0) 又会交换一次，等于白做了。这属于“偷鸡不成蚀把米”的典型错误。

左右翻转时，内层循环是 range(n // 2)。n 是奇数时，中间的列会翻转到自己，不需要处理。比如 n=3，j=0 交换 [0][0] 和 [0][2]，j=1 对应 [0][1] 和 [0][1]，不动。n 是偶数时，正好两两配对。

4.5 两种 O(1) 空间解法的对比

从工程代码的可维护性和面试表达的角度，我个人更推荐翻转法。它不需要在脑内构建四元素环，只需要记住两个简单的几何操作。而且当你需要实现“逆时针旋转90度”时，翻转法只要改成“转置 + 上下翻转”，思路完全一致，扩展性也更强。

5. 通用规律：任意角度旋转与任意矩阵规模的推导

很多人刷完这道题就跳过去了，但其实可以继续深挖：如果旋转角度是 180 度、270 度，怎么处理？如果是 m x n 的矩形矩阵而不是 n x n 的方阵，怎么办？把这些问题想清楚，你对“旋转矩阵”这个知识点的理解才算闭环。

5.1 旋转 180 度：坐标映射的特殊情况

顺时针旋转 180 度，等价于每个元素 (i, j) 去 (n-1-i, n-1-j)。这比 90 度简单，因为不需要四元素环，只需要每对对角元素交换一次。

python复制def rotate_180(matrix):
    n = len(matrix)
    for i in range(n):
        for j in range(n):
            if i < n-1-i or (i == n-1-i and j < n-1-j):
                matrix[i][j], matrix[n-1-i][n-1-j] = matrix[n-1-i][n-1-j], matrix[i][j]

条件判断稍微啰嗦。更优雅的方式是：先上下翻转，再左右翻转。两步一叠加，就是 180 度旋转。

python复制def rotate_180(matrix):
    n = len(matrix)
    matrix.reverse()          # 上下翻转
    for row in matrix:
        row.reverse()         # 左右翻转

如果要逆时针旋转 90 度，用翻转法就是“先上下翻转，再转置”，或者“先转置，再上下翻转”。这两个方向都能到达同一个结果，任选其一即可。

5.2 270 度旋转：别重新推，直接复用 90 度

顺时针旋转 270 度，等价于逆时针旋转 90 度，也等价于顺时针旋转 90 度三次。如果你已经实现了一个 90 度旋转函数，那直接调用三次就行：

python复制def rotate_270(matrix):
    rotate_90(matrix)
    rotate_90(matrix)
    rotate_90(matrix)

虽然调三次的时间复杂度是 3 * O(n^2)，但 n 的规模通常不会太大，这点常数开销完全可以接受。真正重要的是：你不需要为 270 度单独维护一套坐标映射逻辑，代码可维护性大幅提升。

如果想优化成一次遍历，也可以推导出映射公式 (i, j) -> (n-1-j, i)，然后四元素环换成对应的坐标变换。但我个人建议，除非对性能有极致要求，否则复用 90 度函数更符合工程思维。

5.3 矩形矩阵的情况：为什么需要额外矩阵

如果输入不是 n x n 方阵，而是 m x n 矩形，旋转 90 度后的尺寸会从 m x n 变成 n x m。这种情况下，原地旋转在大多数编程语言里都做不到——你不能在一个 m x n 大小的内存区域里存储一个 n x m 的结果，除非数据结构的存储方式支持动态改变维度。

所以在面对矩形矩阵时，老老实实开新矩阵：

python复制def rotate_rect(matrix):
    m = len(matrix)
    n = len(matrix[0])
    res = [[0] * m for _ in range(n)]
    for i in range(m):
        for j in range(n):
            res[j][m-1-i] = matrix[i][j]
    return res

很多面试题会故意在“方阵”和“矩阵”之间做文章，如果你没注意输入是矩形，直接套用原地旋转的代码，大概率会产生数组越界或者输出形状错误。先把问题看清楚，再决定用哪种策略，这是写代码的基本素养。

5.4 广义旋转：用矩阵乘法统一所有情况

从更抽象的数学视角看，旋转操作可以用一个 2x2 的旋转矩阵表示：

顺时针 90 度的线性变换是 [[0, 1], [-1, 0]]，作用于向量 (x, y) 会得到 (y, -x)。但要注意，图像坐标系的 y 轴方向是向下的，所以实际应用时符号会有所不同。如果你在图形学或者游戏开发中处理 sprite 旋转，通常底层就是这种矩阵乘法，而不是手写 for 循环。

矩阵乘法思路适合在 GPU 上并行执行，处理超大图像时效率远高于逐元素交换。这也是“理解算法原理”和“工程实现”之间的一个区别：算法题教给你映射逻辑，工程上你有更多工具可以选。

5.5 从方阵到卷积核旋转的联想

顺手提一个有意思的迁移应用：在做图像卷积时，卷积核有时需要旋转 180 度来实现“相关”和“卷积”之间的等价转换。你会发现，这个操作本质上就是对一个小矩阵做 180 度翻转。理解了本章的旋转规律，再去看深度学习框架里的卷积实现，会更容易理解它们内部在做什么。

6. 热搜词背后的联想：从矩阵旋转到工程中的“模拟思维”

文章开头提到，这题属于典型的“模拟题”。而热搜词里出现了一长串和“模拟”相关的词——从“软件模拟SPI”“模拟鼠标点击”到“分子动力学模拟”“LAMMPS模拟CO2驱油”——这个“模拟”的覆盖面非常广。这里我想聊一聊我在不同场景下体会到的“模拟思维”和矩阵旋转这类算法题的关联，以及它为什么值得你花时间深挖。

6.1 模拟题和仿真模拟的共通点：先定规则，再按规则执行

算法里的模拟题，思路是先理解清楚规则，再把规则翻译成代码逐帧执行。顺时针旋转矩阵的规则清楚得不能再清楚：位置 A 的元素去位置 B，位置 B 的去位置 C。你只需要保证翻译过程没有歧义，不重不漏。

工程上的模拟，比如“软件模拟SPI”或者“模拟鼠标运动轨迹”，思路完全一样：硬件 SPI 协议规定时钟线在上升沿采样数据、数据线在某个相位输出，你就在代码里按这个时序逐 bit 生成波形；鼠标的运动轨迹是贝塞尔曲线还是线性插值，你按照轨迹公式逐点计算坐标。

两者的核心相通之处在于“忠实复现一套既定的行为规则”，难点也一致：“边界时序对不对”“状态切换先后顺不顺”“会不会有竞态条件”。

6.2 一个真实的例子：软件模拟 SPI 和矩阵旋转的相似性

有段时间我在嵌入式项目里做过一次软件模拟 SPI，因为在那个单片机上硬件 SPI 引脚被复用了，只能靠 GPIO 翻转电平去“模拟”。

模拟读一个字节的代码大概是：

c复制uint8_t sw_spi_read(void) {
    uint8_t data = 0;
    for (int i = 7; i >= 0; i--) {
        SPI_CLK_HIGH();
        delay_us(1);
        if (GPIO_READ(SPI_MISO)) {
            data |= (1 << i);
        }
        SPI_CLK_LOW();
        delay_us(1);
    }
    return data;
}

这里的核心问题是什么？是时序。每个 bit 的采样点必须在时钟上升沿之后、下一个沿之前稳定下来。如果你把 delay_us 去掉或者顺序写反，数据读出来就是乱的。

这和矩阵旋转的“循环覆盖顺序”是不是很有共鸣？矩阵旋转里四元素覆盖顺序错了，整个环的数据就互相污染；SPI 模拟里采样和时钟沿的顺序错了，整帧数据就错位了。都是模拟题，都是在“按规则办事”，但规则里藏着大量细节。

6.3 为什么“模拟题”看起来不难，却总有人写错

我在刷题群和面试里观察到一个现象：很多人觉得模拟题“简单”，但一到手写就漏洞百出。原因不是不懂规则，而是“实现规则时没有把所有状态穷举清楚”。

矩阵旋转你要考虑 n 的奇偶性、每一圈的起点集合、每一圈的边长、四元素环的覆盖方向，漏一个就错。软件模拟 SPI 你要考虑时钟极性和相位、MSB 还是 LSB 先行、片选信号的拉高拉低时机，漏一个通信就失败。

这类问题的共性解决方案：先把问题“形式化”。你可以在写代码之前把输入输出、中间状态、边界条件全部写出来，再动手编码。这比边写边想靠谱得多，也更容易让面试官看到你的思考过程。

6.4 模拟思维在其他领域的具体形态

不只是代码，很多领域都有“模拟”的影子。比如“模拟电路”“模拟IC”这种说法，虽然和“模拟算法”的“模拟”不是一个意思（前者是 analog，后者是 simulation），但它们也共享一种“贴近真实物理行为”的精神。模拟电路设计要考虑电压电流的连续变化，而不是离散的 0/1 逻辑；算法模拟则要考虑每一步的连续状态，而不是只看最终结果。

再比如“分子动力学模拟”和“LAMMPS模拟CO2驱油”，那是把物理系统离散成时间步，每一步计算原子间的力，更新位置和速度。这个循环你拆开看，和矩阵旋转的嵌套循环一样，本质上都是“时间或空间上按规则推进”。你只是把“交换矩阵元素”换成了“更新原子坐标”。

6.5 从刷题到工程：把“能 AC”变成“会设计”

如果你只是背下矩阵旋转的代码，那它只是一个知识点；但如果你能把它背后的思考方式迁移出去，它就是一种解决问题的能力。具体怎么迁移？

第一，遇到任何看起来“有规则、可拆解、需要逐步操作”的问题，先问自己：状态的表示是什么？边界条件有哪些？每一步的先后顺序影响结果吗？这三个问题想清楚，基本就成功了一半。

第二，写代码前先用小例子手动演算一遍。比如 2x2、3x3、4x4，把这些小例子在纸上跑一遍，你能发现规律，也能验证代码逻辑。绝大多数人在矩阵旋转上出错，就是因为跳过了手动演算，直接上了大矩阵，结果错误被掩盖在大量数据里，很难排查。

第三，把“模拟”和“数学优化”看成互补关系。模拟题通常直观、可验证，但不一定最优；数学优化可能不直观，但能提升效率。矩阵旋转里，朴素模拟（额外矩阵）和数学优化（转置+翻转）就是一对典型。工程中你往往需要根据场景权衡，而不是一味追求最优。

6.6 一个额外的彩蛋：从矩阵旋转到图像处理和游戏开发

矩阵旋转在图像处理和游戏开发里太常用了。图像旋转、手机横竖屏切换、游戏地图的 tile 旋转，背后都离不开矩阵操作。

而且不只是二维。三维空间里的旋转涉及欧拉角、四元数、旋转矩阵，那是一个更大的话题，但核心思想和二维的“坐标映射”一脉相承。你从一道算法题开始，能一路串到三维图形学的旋转体系，这个过程本身就很有价值。

7. 边界条件、复杂度分析和面试进阶问题

最后一部分专门用来整理一些“大概率会在面试中被追问”的细节。无论你用的是四元素法还是翻转法，这些细节都能帮你从容应对面试官的追问。

7.1 边界条件的自查清单

无论写哪种解法，写完代码后都要快速自查这些点：

• n 为 0 或 1：矩阵不需要做任何操作，你的代码会不会直接返回？
• n 为偶数：每一圈的元素数量是否是 4 的倍数，闭环是否正常？
• n 为奇数：最中心元素是否被意外交换？
• 每圈处理元素数：对于第 i 圈，是否正好处理了 n - 2*i - 1 个“闭环起点”？
• 循环范围：外循环 n//2，内循环 n-1-i，有没有差一错误？

这些自查点都过一遍，代码基本就不会出问题。

7.2 复杂度分析的准确表述

• 时间复杂度：O(n^2)。因为 n x n 矩阵的每个元素都需要被访问并移动一次，这里 n 是矩阵的边长。
• 空间复杂度：四元素法和翻转法都是 O(1)，因为只用了一个临时变量；朴素方法 O(n^2)。

面试时如果被问“能不能更优”，你要能反问：你认为的"更优"是指时间还是空间？因为时间复杂度已经达到理论下界，没有提升空间；空间已经 O(1)，也没有提升空间。这个问题本身问得就不太恰当，你要敢于指出。

7.3 面试官可能追问的变体题

1. 逆时针旋转 90 度怎么实现？
   • 翻转法：先上下翻转，再转置；或者先转置，再左右翻转。
2. 旋转 180 度呢？
   • 翻转法：先上下翻转，再左右翻转。
3. 输入是矩形不是方阵怎么办？
   • 必须用额外矩阵，因为输出尺寸变了，无法在 m x n 空间内原地存储 n x m 的结果。
4. 如果要处理超大规模矩阵但内存有限，怎么旋转？
   • 可能需要分块处理，每次加载一部分到内存，处理完再写回。这属于工程的扩展话题，能答出来会很加分。

7.4 从“过题”到“内化”：一条实用的练习路径

如果你真想把这题吃透，我建议按下面的顺序练习：

1. 不参考任何资料，自己写出朴素解（新矩阵）。
2. 推导出坐标映射公式。
3. 基于坐标映射，尝试写出四元素原地旋转。
4. 理解转置 + 翻转的几何含义，并手写翻转法。
5. 用几个不同尺寸的矩阵分别验证两种解法，包括 n=1,2,3,4,5。
6. 尝试实现逆时针旋转和 180 度旋转，看能不能复用已有的 90 度函数。
7. 如果有多余精力，研究一下二维矩阵旋转和三维旋转的关系。

这个过程走完，你就不只是“会做这道题”，而是把“矩阵旋转”纳入了自己的知识体系。以后再遇到类似问题，你会有一种很自然的“这个问题我熟”的感觉。

从我刷题和面试的经验看，真正拉开差距的往往不是谁记住了更多的题解，而是谁能在有限时间内把一道题背后的规律和边界梳理清楚。顺时针旋转矩阵这道题，不大不小，刚好是一个用来打磨这种能力的绝佳样例。把它的“为什么”真正想透，比多做十道同类型题更有价值。