算法系列--Rotate Image

  今天仍然来分析一个与数组操作相关的算法，是关于二维数组旋转问题的。

---

问题描述

原文

You are given an n × n 2D matrix representing an image.
Rotate the image by 90 degrees (clockwise).
Follow up: Could you do this in-place?

大意：给一个 n * n 的二维矩阵表示的图像，将这个图像顺时针旋转90°。
例如给一个 3 * 3矩阵，
[
 [1,2,3 ]
 [4,5,6 ]
 [7,8,9 ]
]
顺时针旋转90°后，
[
 [7,4,1 ]
 [8,5,2 ]
 [9,6,3 ]
]

思路分析

  首先最容易想到的就是创建一个新的n * n矩阵来存储结果，然后将原矩阵的对应行存储到结果矩阵的对应列即可。经过简单分析，可以发现原矩阵中（i,j）位置的元素，在结果矩阵中位置应该是（j,n-1-i）。有了对应关系我们可以很快写出如下的代码：

/*
 * 模拟法：时间复杂度 O(n²) ，空间复杂度 O(n²)
 */
public static void rotate5(int[][] matrix) {
    int m = matrix.length;
    int n = matrix[0].length;
    if (m != n)
        return;
    int[][] result = new int[n][n];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) {
            result[j][n - 1 - i] = matrix[i][j];
        }
    //print(result);//打印结果（方法不再给出）
}

说明：这种方法的优势就是容易理解，算法简单，不足就是需要额外占用辅助空间。

算法改进

  如果不申请辅助空间，直接在原矩阵上操作，那么我们应该怎么做呢？如果仍按照上述的操作直接赋值，那么就会直接覆盖掉原本数组当中的元素，数据信息将丢失。换一种思路，矩阵顺时针反转90度之后的结果不过是将数组掉了个方向而已，其实通过矩阵的对称翻转操作其实也可以实现这种掉个儿的最终效果，所不同的是顺时针翻转90度不能通过一次简单的对称翻转操作得到，可能需要多次。现在我们需要找到这种对称翻转操作和顺时针翻转90度效果之间的过渡方法。
  矩阵的对称翻转操作分为两种，对角线翻转（主，副） 和 中线翻转（水平，垂直），通过这两种翻转的组合可以达到顺时针翻转90度的效果。例如，我们对最简单的二维数组{{1,2}，{3,4}}分析，按主对角线翻转一次后，得到{{1,3}，{2,4}}，再按垂直中线翻转一次后，得到{{3,1}，{4,2}},可以看到这就是我们需要的结果。对翻转操作做排列组合筛选后，我们一共可以找到4种方法来得到最终结果。

• 方法1：先按主对角线翻转，再按垂直中线翻转。

  /*
       * 反转图像1:主对角线反转，垂直中线反转 时间复杂度 O(n^2) ，空间复杂度 O(1)
       */
  public static void rotate1(int[][] matrix) {
          int m = matrix.length;
          int n = matrix[0].length;
          if (m != n)
              return;
          int temp;
          for (int i = 0; i < n; i++)
              for (int j = 0; j < i; j++) {
                  temp = matrix[i][j];
                  matrix[i][j] = matrix[j][i];
                  matrix[j][i] = temp;
              }
          System.out.println("主对角线反转后：");
          print(matrix);
          for (int i = 0; i < n; i++)
              for (int j = 0; j < n / 2; j++) {
                  temp = matrix[i][j];
                  matrix[i][j] = matrix[i][n - 1 - j];
                  matrix[i][n - 1 - j] = temp;
              }
          System.out.println("垂直中线反转后：");
          print(matrix);
      }
  

• 方法2：先按副对角线翻转，再按水平中线翻转

  /*
       * 副对角线反转，水平中线反转 时间复杂度 O(n^2) ，空间复杂度 O(1)
       */
  
      public static void rotate2(int[][] matrix) {
          int m = matrix.length;
          int n = matrix[0].length;
          if (m != n)
              return;
          int temp;
  
          for (int i = 0; i < n; i++)
              for (int j = 0; j < n - 1 - i; j++) {
                  temp = matrix[i][j];
                  matrix[i][j] = matrix[n - 1 - j][n - 1 - i];
                  matrix[n - 1 - j][n - 1 - i] = temp;
              }
          System.out.println("副对角线反转后：");
          print(matrix);
          for (int i = 0; i < n / 2; i++)
              for (int j = 0; j < n; j++) {
                  temp = matrix[i][j];
                  matrix[i][j] = matrix[n - 1 - i][j];
                  matrix[n - 1 - i][j] = temp;
              }
          System.out.println("水平中线反转后：");
          print(matrix);
      }
  

• 方法3：先按水平中线翻转，再按主对角线翻转

  /*
       * 水平中线反转，主对角线反转 时间复杂度 O(n^2) ，空间复杂度 O(1)
       */
      public static void rotate3(int[][] matrix) {
          int m = matrix.length;
          int n = matrix[0].length;
          if (m != n)
              return;
          int temp;
          for (int i = 0; i < n / 2; i++)
              for (int j = 0; j < n; j++) {
                  temp = matrix[i][j];
                  matrix[i][j] = matrix[n - 1 - i][j];
                  matrix[n - 1 - i][j] = temp;
              }
          System.out.println("水平中线反转后：");
          print(matrix);
          for (int i = 0; i < n; i++)
              for (int j = 0; j < i; j++) {
                  temp = matrix[i][j];
                  matrix[i][j] = matrix[j][i];
                  matrix[j][i] = temp;
              }
          System.out.println("主对角线反转后：");
          print(matrix);
  
      }
  

• 方法4：先按垂直中线翻转，再按副对角线翻转

  /*
       * 垂直中线反转，副对角线反转 时间复杂度 O(n^2) ，空间复杂度 O(1)
       */
      public static void rotate4(int[][] matrix) {
          int m = matrix.length;
          int n = matrix[0].length;
          if (m != n)
              return;
          int temp;
          for (int i = 0; i < n; i++)
              for (int j = 0; j < n / 2; j++) {
                  temp = matrix[i][j];
                  matrix[i][j] = matrix[i][n - 1 - j];
                  matrix[i][n - 1 - j] = temp;
              }
          System.out.println("垂直中线反转后：");
          print(matrix);
  
          for (int i = 0; i < n; i++)
              for (int j = 0; j < n - 1 - i; j++) {
                  temp = matrix[i][j];
                  matrix[i][j] = matrix[n - 1 - j][n - 1 - i];
                  matrix[n - 1 - j][n - 1 - i] = temp;
              }
          System.out.println("副对角线反转后：");
          print(matrix);
      } 
  

  说明：以上四种方法思路基本类似，关键在于找出对称情况下，元素（i,j）与对称翻转后新位置（m,n）之间的数量关系。另外，代码提到的print(int[][] martrix)打印数组的方法不再给出，读者可以自行补充。