题解 | 顺时针旋转矩阵

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
     *
     *
     * @param mat int整型二维数组
     * @param n int整型
     * @return int整型二维数组
     */
    public int[][] rotateMatrix (int[][] mat, int n) {
        // 参数校验
        if (mat == null || n <= 1 || mat.length != n || mat[0].length != n) {
            return mat;
        }

        for (int i = 0; i < n / 2; i++) {
            for (int j = i; j < n - 1 - i; j++) {
                int temp = mat[i][j];
                mat[i][j] = mat[n - 1 - j][i];
                mat[n - 1 - j][i] = mat[n - 1 - i][n - 1 - j];
                mat[n - 1 - i][n - 1 - j] = mat[j][n - 1 - i];
                mat[j][n - 1 - i] = temp;
            }
        }

        return mat;
    }
}

我来详细解释一下矩阵旋转算法的每一步:

1、参数校验

if (mat == null || n <= 1 || mat.length != n || mat[0].length != n) {
    return mat;
}
  • 这一步检查:
  • 矩阵是否为空(mat == null
  • 矩阵大小是否小于等于1(n <= 1),如果是则无需旋转
  • 矩阵是否真的是n×n的(mat.length != n || mat[0].length != n
  • 2、遍历策略

    for (int i = 0; i < n/2; i++) {
        for (int j = i; j < n-1-i; j++) {
    
  • 外层循环 i < n/2:只需要处理矩阵的前一半行
  • 内层循环 j < n-1-i:对于每一行,只需要处理到n-1-i列
  • 这样的遍历方式可以保证只处理矩阵的1/4,避免重复旋转
  • 3、四点旋转

    假设有一个4×4矩阵:

    [1  2  3  4]
    [5  6  7  8]
    [9  10 11 12]
    [13 14 15 16]
    

    对于位置(i,j),需要旋转的四个点是:

    temp = mat[i][j];                    // 保存当前位置的值
    mat[i][j] = mat[n-1-j][i];          // 左边 → 上边
    mat[n-1-j][i] = mat[n-1-i][n-1-j];  // 下边 → 左边
    mat[n-1-i][n-1-j] = mat[j][n-1-i];  // 右边 → 下边
    mat[j][n-1-i] = temp;               // 上边 → 右边
    

    以第一次旋转为例(i=0, j=0):

  • temp = mat[0][0] = 1
  • mat[0][0] = mat[3][0] = 13 // 13移到1的位置
  • mat[3][0] = mat[3][3] = 16 // 16移到13的位置
  • mat[3][3] = mat[0][3] = 4 // 4移到16的位置
  • mat[0][3] = temp = 1 // 1移到4的位置
  • 一次完整的旋转后:

    [13 2  3  1]
    [5  6  7  8]
    [9  10 11 12]
    [16 14 15 4]
    

    继续进行下一个位置的旋转,直到完成所有需要的旋转操作。

    为什么只需要遍历1/4的矩阵?

  • 每次旋转操作都同时处理了4个位置
  • 如果继续遍历剩下的部分,会导致已经旋转过的元素再次被旋转,破坏结果
  • 时间复杂度分析:

  • 虽然看起来是两层循环,但实际上只遍历了矩阵的1/4
  • 时间复杂度仍然是O(n²),但实际操作次数比遍历整个矩阵少了很多
  • 这种方法比之前的"先对角线翻转再垂直翻转"的方法更高效,因为每个元素只被移动一次。

    全部评论

    相关推荐

    评论
    点赞
    收藏
    分享

    创作者周榜

    更多
    牛客网
    牛客企业服务