程序员面试经典—— 01.07. 旋转矩阵

01.07. 旋转矩阵

已解答

中等

给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 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]
]

注意：本题与主站 48 题相同：https://leetcode-cn.com/problems/rotate-image/

尝试一：借用额外数组空间(推理)

1.推理

例矩阵为:
1,2,3
4,5,6
7,8,9

一.数值变化:
1,2,3
4,5,6
7,8,9
转换为:
7,4,1
8,5,2
9,6,3

二.坐标变化:
1{0,0}	2{0,1}	3{0,2}
4{1,0}	5{1,1}	6{1,2}
7{2,0}	8{2,1}	9{2,2}

转换为:		
7{0,1}	4{0,1}	1{0,2}
8{1,0}	5{1,1}	2{1,2}
9{2,0}	6{2,1}	3{2,2}

2.推导结果

matrix[0][0] -> newMatrix[0][2]
matrix[0][1] -> newMatrix[1][2]
matrix[0][2] -> newMatrix[2][2]

matrix[1][0] -> newMatrix[0][1]
matrix[1][1] -> newMatrix[1][1]
matrix[1][2] -> newMatrix[2][1]

matrix[2][0] -> newMatrix[0][0]
matrix[2][1] -> newMatrix[1][0]
matrix[2][2] -> newMatrix[2][0]

这样就可以得到顺时针旋转90度后的新矩阵。从上述规律中发现：

1. 只需要将原有的i位置替换为j，也就是newMatrix[j][i]
2. 设n=矩阵的长度length随后发现现在在j位置上的i需要替换成n-1-i,也就是newMatrix[n-i-1]

最终推导出来的替换公式为：
$$newMatrix[j][n-1-i]=matrix[i][j]$$

实现代码

在代码中，使用双重循环遍历原矩阵，将原矩阵中的元素按照这个规则复制到新的矩阵中。

    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int length = matrix.length;
        int[][] newMatrix = new int[length][length];
        //双重循环遍历按照推导公式遍历赋值给newMatrix
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++){
                //推导公式,数组长度与实际下标相差1故此-1
                newMatrix[j][length - 1 -i] = matrix[i][j];
                //打印原数组
                System.out.print(matrix[i][j]);
                if(j != length - 1) System.out.print(" ");
            }
            System.out.println();
        }
        System.out.println("================================");
        System.out.println("旋转后如下:");
        //打印目标旋转后的矩阵
        for (int i = 0; i < newMatrix.length; i++) {
            for (int j = 0; j < newMatrix[i].length; j++) {
                System.out.print(newMatrix[i][j]);
                if(j != length - 1) System.out.print(" ");
            }
            System.out.println();
        }
    }

注：不可直接赋值，使用了int[][] newMatrix = matrix;将newMatrix引用指向了matrix的地址。这意味着newMatrix和matrix指向同一块内存，它们实际上是同一个数组。

3.最终代码

/**m:7.20%
占用额外数组
 */
class Solution {
    public void rotate(int[][] matrix) {
        int length = matrix.length;
        int[][] newMatrix = new int[length][length];
        for(int i = 0; i < length; i++){
            for(int j = 0; j < length; j++){
                newMatrix[j][length - 1 - i] = matrix[i][j];
            }
        }
         for(int i = 0; i < length; i++){
            for(int j = 0; j < length; j++){
                 matrix[i][j] = newMatrix[i][j];
            }
        }
    }
}

尝试二：对角/中线翻转

1.推理

当考虑如何原地旋转矩阵的时候，可以通过一系列翻转操作来实现。详细推导过程如下：

2.推导步骤

先对于一个N x N的矩阵，需要将其按对角线翻转

也就是将矩阵的元素matrix[i][j]和matrix[j][i]进行交换

before
1{0,0}	2{0,1}	3{0,2}
4{1,0}	5{1,1}	6{1,2}
7{2,0}	8{2,1}	9{2,2}

after
1{0,0}	4{0,1}	7{0,2}
2{1,0}	5{1,1}	8{1,2}
3{2,0}	6{2,1}	9{2,2}

这一步是为了将矩阵的行和列进行互换

例如，考虑一个3x3的矩阵：

1 2 3
4 5 6
7 8 9

在对角线翻转时，我们只需要处理上三角部分，即：

1 x x
4 5 x
7 8 9

如果我们不使用j = i + 1，而是直接从j = 0开始，那么我们将处理整个矩阵，包括对称轴上的元素，导致元素重复翻转。

因此，j = i + 1是确保我们只操作矩阵的上三角部分的一种常见写法。

实现代码如下：

    public static void main(String[] args) {
        int[][] matrix = {{1,2,3},{4,5,6},{7,8,9}};
        for (int i = 0; i < matrix.length; i++) {
            for (int j = i + 1; j < matrix[i].length; j++) {
                int temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }
        //打印
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j]);
                if(j != matrix[i].length) System.out.print(" ");
            }
            System.out.println();
        }
    }

随后按照中位线互换

before
1{0,0}	4{0,1}	7{0,2}
2{1,0}	5{1,1}	8{1,2}
3{2,0}	6{2,1}	9{2,2}

after
7{0,0}	4{0,1}	1{0,2}
8{1,0}	5{1,1}	2{1,2}
9{2,0}	6{2,1}	3{2,2}

经过这两个步骤，我们完成了矩阵的顺时针旋转90度的操作。这两个步骤中的翻转操作是原地进行的，没有使用额外的数组空间。

实现代码如下：

    public static void main(String[] args) {
        int[][] matrix = {{1,2,3},{4,5,6},{7,8,9}};
        for (int i = 0; i < matrix.length; i++) {
            //设matrix如此例,只是中位线前半部分的元素执行交换就可以了
            for (int j = 0; j < matrix[i].length / 2; j++) {
                //交换matrix[i][j]和matrix[i][matrix.length - 1 -j]
                int temp = matrix[i][j];
                matrix[i][j] = matrix[i][matrix.length - 1 - j];
                matrix[i][matrix.length - 1 - j] = temp;
            }
        }
        //打印
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j]);
                if(j != matrix[i].length) System.out.print(" ");
            }
            System.out.println();
        }
    }

3.最终代码

/**28.56%
1.对角线替换
2.中位线替换
 */
class Solution {
    public void rotate(int[][] matrix) {
        //1.对角线替换
        for(int i = 0;i < matrix.length;i++){
            //int j = i + 1 对角线右上三角遍历到再替换
            for(int j = i + 1;j < matrix[i].length; j++){
                int temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }
        //2.中位线替换
        for(int i = 0;i < matrix.length; i++){
            //j < matrix[i].length / 2遍历中位线前的元素时替换即可
            for(int j = 0;j < matrix[i].length / 2; j++){
                int temp = matrix[i][j];
                matrix[i][j] = matrix[i][matrix.length - 1 - j];
                matrix[i][matrix.length - 1 - j] = temp;
            }
        }
    }
}