LeetCode 48. Rotate Image【原地算法+矩阵转置+反转矩阵】⭐⭐⭐⭐⭐

题目描述

知识点

数组操作

结果

实现

码前思考

1. 这道题我实现的实在是太蠢了，虽然是双百的结果，但是却用了我很长时间，我并不打算使用这种方法来写题解。。。
2. 按照LeetCode题解的说法，应该先将矩阵转置，再将反转列向量。
3. 矩阵转置 是(i,j)与(j,i)之间交换，因此可以实现原地；
4. 反转列向量 这个我一开始没有想到怎么原地，后来看题解才发现，就是原地反转一维数组那种思想，第一列与最后一列置换，第二列与倒数第二列置换！

代码实现

class Solution {
  public void rotate(int[][] matrix) {
    int n = matrix.length;

    // transpose matrix
    for (int i = 0; i < n; i++) {
      for (int j = i; j < n; j++) {
        int tmp = matrix[j][i];
        matrix[j][i] = matrix[i][j];
        matrix[i][j] = tmp;
      }
    }
    // reverse each row
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n / 2; j++) {
        int tmp = matrix[i][j];
        matrix[i][j] = matrix[i][n - j - 1];
        matrix[i][n - j - 1] = tmp;
      }
    }
  }
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/rotate-image/solution/xuan-zhuan-tu-xiang-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

我的傻逼解法：

//采用迭代的方式进行旋转
class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int size = matrix.size();
        //最多需要循环的次数
        int limit = size/2;

        //下面开始循环
        for(int i=0;i<limit;i++){
            int cursize = size-2*i;
            //printf("i:%d--------------------------\n",i);
            //循环进行前进,j代表循环的最大次数
            for(int j=i;j<i+cursize-1;j++){
                //printf("    j:%d--------------------------\n",j);
                //不变量
                int lefty = i;
                int downx = size-1-i;
                int righty = size-1-i;
                int upx = i;

                //会变量
                int upy = j;
                int leftx = i + (downx - upy);
                int downy = leftx;
                int rightx = upy;
                // printf("%d %d\n",leftx,lefty);
                // printf("%d %d\n",downx,downy);
                // printf("%d %d\n",rightx,righty);
                // printf("%d %d\n",upx,upy);
                //临时变量
                int tmp = matrix[upx][upy];

                //列号固定
                matrix[upx][upy] = matrix[leftx][lefty]; 

                //行号固定
                matrix[leftx][lefty] = matrix[downx][downy];

                //列号固定
                matrix[downx][downy] = matrix[rightx][righty];

                matrix[rightx][righty] = tmp;
            }
        }
    }
};

码后反思

1. 其实一开始我想到了矩阵转置，但是没想到怎么进行原地地矩阵转置和没想到矩阵反转，我还是太菜了
2. 好久没写题了，思维倒退了，哈哈哈。

二刷代码

依然用的是非常蠢的方法，还是没有想到使用矩阵转置和交换列向量的方法。。。

//采用传统的方式进行图形的旋转
class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        //首先计算一共需要多少层
        int size = matrix.size();

        int n = size/2;//需要旋转的层数
        //printf("%d\n",n);

        for(int i=0;i<n;i++){
            //printf("i:%d\n",i);
            int left = i;
            int right = size-1-i;
            int up = i;
            int down = size-1-i;

            for(int j=0;j<size-i*2-1;j++){//表示变长的数量
                //printf("j:%d\n",j);
                int tmp = matrix[up][left+j];
                matrix[up][left+j] = matrix[down-j][left];
                matrix[down-j][left] = matrix[down][right-j];
                matrix[down][right-j] = matrix[up+j][right];
                matrix[up+j][right] = tmp;
            }
        }
    }
};