每日一题——顺时针旋转矩阵

顺时针旋转矩阵

目录

• 一、问题描述
• 二、解题思路
  • 1. 原地旋转矩阵
  • 2. 旋转逻辑
  • 3. 代码实现
• 三、代码解析
  • 1. 参数说明
  • 2. 原地旋转逻辑
  • 3. 返回矩阵
• 四、示例测试代码
• 五、复杂度分析
  • 1. 时间复杂度
  • 2. 空间复杂度

一、问题描述

以下是内容转换为 优快云 的 Markdown 格式：

---

问题描述

给定一个 N * N\的整数矩阵，请编写一个算法将其顺时针旋转 90 度。旋转后的矩阵需要返回。例如，给定矩阵：

1  2  3 
4  5  6 
7  8  9 

旋转 90 度后应变为：

7  4  1 
8  5  2 
9  6  3 

---

说明

• 矩阵的旋转操作是原地进行的，即不额外分配空间。
• 示例中的矩阵旋转后，行和列的值发生了相应的变化。

数据范围

• (0 < n < 300)
• 矩阵中的值满足 (0 \leq val \leq 1000)

复杂度要求

• 空间复杂度：(O(1))
• 时间复杂度：(O(N^2))

二、解题思路

1. 原地旋转矩阵

为了满足空间复杂度 (O(1)) 的要求，我们需要在原矩阵上直接进行操作，而不是使用额外的空间。具体步骤如下：

1. 分层旋转：矩阵可以分为多层，每一层从外到内逐步旋转。
2. 旋转步骤：
   • 保存左上角的值。
   • 按顺时针方向依次交换四个位置的值。

2. 旋转逻辑

对于每个元素 ((i, j))，其旋转后的位置可以通过以下公式计算：

• 新行索引 (i’ = j)
• 新列索引 (j’ = N - i - 1)

3. 代码实现

以下是完整的C语言实现代码，包含详细的注释：

#include <stdio.h>
#include <stdlib.h>

/**
 * 顺时针旋转矩阵90度
 * @param mat: 输入矩阵
 * @param matRowLen: 矩阵的行数
 * @param matColLen: 矩阵的列数（每行的长度）
 * @param n: 矩阵的阶数（n x n）
 * @param returnSize: 返回矩阵的行数
 * @param returnColumnSizes: 返回矩阵的列数（每行的长度）
 * @return: 旋转后的矩阵
 */
int** rotateMatrix(int** mat, int matRowLen, int* matColLen, int n,
                   int* returnSize, int** returnColumnSizes) {
    // 设置返回矩阵的行数和列数
    *returnSize = n;  // 设置返回矩阵的行数为n
    *returnColumnSizes = (int*)malloc(n * sizeof(int));  // 分配内存用于存储每行的列数
    for (int i = 0; i < n; i++) {
        (*returnColumnSizes)[i] = n;  // 每行的列数也为n
    }

    // 原地旋转矩阵
    for (int layer = 0; layer < n / 2; layer++) {  // 遍历每一层，从外层到内层
        int first = layer;  // 当前层的起始索引
        int last = n - layer - 1;  // 当前层的结束索引
        for (int i = first; i < last; i++) {  // 遍历当前层的每个元素
            int gap = i - first;  // 当前元素与起始索引的偏移量
            int temp = mat[first][i];  // 保存左上角的值

            // 左上 <- 左下
            mat[first][i] = mat[last - gap][first];

            // 左下 <- 右下
            mat[last - gap][first] = mat[last][last - gap];

            // 右下 <- 右上
            mat[last][last - gap] = mat[i][last];

            // 右上 <- 左上（保存的值）
            mat[i][last] = temp;
        }
    }

    // 返回原地旋转后的矩阵
    return mat;
}

三、代码解析

1. 参数说明

• mat：输入的二维矩阵。
• matRowLen：矩阵的行数。
• matColLen：矩阵的列数（每行的长度）。
• n：矩阵的阶数（矩阵是 (n \times n) 的）。
• returnSize：返回矩阵的行数（通过指针返回）。
• returnColumnSizes：返回矩阵的列数（每行的长度，通过指针返回）。

2. 原地旋转逻辑

• 分层旋转：矩阵可以分为多层，每一层从外到内逐步旋转。
• 旋转步骤：
  1. 保存左上角的值：将左上角的值保存到临时变量 temp。
  2. 左上 <- 左下：将左下角的值移动到左上角。
  3. 左下 <- 右下：将右下角的值移动到左下角。
  4. 右下 <- 右上：将右上角的值移动到右下角。
  5. 右上 <- 左上（保存的值）：将保存的左上角的值移动到右上角。

3. 返回矩阵

• 设置返回矩阵的行数和列数：
  • *returnSize = n：返回矩阵的行数。
  • *returnColumnSizes：返回矩阵的列数（每行的长度）。
• 返回原地旋转后的矩阵 mat。

四、示例测试代码

以下是测试代码，用于验证 rotateMatrix 函数的正确性：

#include <stdio.h>

int main() {
    int n = 3;
    int mat[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int* matPtr[3];
    for (int i = 0; i < n; i++) {
        matPtr[i] = mat[i];
    }

    int returnSize;
    int* returnColumnSizes;
    int** rotated = rotateMatrix(matPtr, n, NULL, n, &returnSize, &returnColumnSizes);

    printf("Rotated Matrix:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", rotated[i][j]);
        }
        printf("\n");
    }

    free(returnColumnSizes);
    return 0;
}

输出

输入：

[[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3

输出：

Rotated Matrix:
7 4 1 
8 5 2 
9 6 3 

五、复杂度分析

1. 时间复杂度

• 每个元素只被访问一次，时间复杂度为 (O(N^2))。

2. 空间复杂度

• 除了输入矩阵外，没有使用额外的空间，空间复杂度为 (O(1))。