43-旋转图像

给定一个 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 度的效果。这种方法代码简洁，效率高，是首选方案。

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

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