中企动力 网站模板短期职业技能培训班

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

示例 1：

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

示例 2：

输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]

提示：

• n == matrix.length == matrix[i].length
• 1 <= n <= 20
• -1000 <= matrix[i][j] <= 1000

方法一：转置加反转法

这种方法先对矩阵进行转置（行列互换），然后反转每一行，从而实现顺时针旋转 90 度的效果。

function rotate(matrix: number[][]): void {const n = matrix.length;// 转置矩阵for (let i = 0; i < n; i++) {for (let j = i; j < n; j++) {[matrix[i][j], matrix[j][i]] = [matrix[j][i], matrix[i][j]];}}// 反转每一行for (let i = 0; i < n; i++) {let left = 0;let right = n - 1;while (left < right) {[matrix[i][left], matrix[i][right]] = [matrix[i][right], matrix[i][left]];left++;right--;}}
}

方法二：分层旋转法

将矩阵分成若干层，每层处理四条边上的元素，实现原地旋转。

function rotate(matrix: number[][]): void {const n = matrix.length;// 矩阵分成n/2层for (let layer = 0; layer < Math.floor(n / 2); layer++) {const first = layer;const last = n - 1 - layer;// 处理当前层的每一列for (let i = first; i < last; i++) {const offset = i - first;// 保存顶部元素const top = matrix[first][i];// 顶部 <- 左侧matrix[first][i] = matrix[last - offset][first];// 左侧 <- 底部matrix[last - offset][first] = matrix[last][last - offset];// 底部 <- 右侧matrix[last][last - offset] = matrix[i][last];// 右侧 <- 顶部matrix[i][last] = top;}}
}

方法三：直接计算位置交换法

通过计算每个元素旋转后的位置，直接进行交换操作。

function rotate(matrix: number[][]): void {const n = matrix.length;const tempMatrix: number[][] = [];// 先创建临时矩阵存储旋转后的结果for (let i = 0; i < n; i++) {tempMatrix[i] = new Array(n);for (let j = 0; j < n; j++) {// 计算旋转后的位置：(i,j) -> (j, n-1-i)tempMatrix[j][n - 1 - i] = matrix[i][j];}}// 将临时矩阵的结果复制回原矩阵for (let i = 0; i < n; i++) {for (let j = 0; j < n; j++) {matrix[i][j] = tempMatrix[i][j];}}
}

复杂度分析

1. 转置加反转法：

   • 时间复杂度：O (n²)，其中 n 是矩阵的边长。需要两次遍历矩阵，每次遍历都是 O (n²)。
   • 空间复杂度：O (1)，直接原地修改矩阵，无需额外空间（除了交换时的临时变量）。

2. 分层旋转法：

   • 时间复杂度：O (n²)，每个元素都被处理一次。
   • 空间复杂度：O (1)，仅使用常数级额外空间。

3. 直接计算位置交换法：

   • 时间复杂度：O (n²)，需要两次遍历矩阵。
   • 空间复杂度：O (n²)，需要一个临时矩阵存储旋转后的结果。

测试示例

// 测试示例1
const matrix1 = [[1, 2, 3],[4, 5, 6],[7, 8, 9]
];
rotate(matrix1);
console.log(matrix1);  // 输出: [[7,4,1],[8,5,2],[9,6,3]]// 测试示例2
const matrix2 = [[5, 1, 9, 11],[2, 4, 8, 10],[13, 3, 6, 7],[15, 14, 12, 16]
];
rotate(matrix2);
console.log(matrix2);  // 输出: [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]

方法说明

• 转置加反转法是最直观且高效的方法，先转置矩阵（行列互换），然后反转每一行，就能得到顺时针旋转 90 度的效果。这种方法代码简洁，效率高，是首选方案。

• 分层旋转法适合理解旋转的具体过程，将矩阵分成若干层，每层处理四条边上的元素，通过四次赋值完成旋转，适合教学和理解矩阵旋转的原理。

• 直接计算位置交换法通过数学计算确定每个元素旋转后的位置，但需要临时矩阵存储结果，不符合 "原地旋转" 的要求，这里列出是为了对比不同的思路。实际应用中应优先选择前两种方法。