不额外开空间的情况下旋转（leetcode48）

思路

额外开空间

matrix[i][j] = matrix[n - 1 - j][i];
可以通过map：
mapp[i * n + j] = matrix[n - 1 - j][i];
不太清楚这样做的内存开销

我奇葩的思路

旋转中如果按照matrix[i][j] = matrix[n - 1 - j][i];有的元素不仅仅被替换一次。
发现如：
1 2 3
4 5 6
7 8 9
这样外圈的1,3,9,7它们是循环的
圈子改变本质类似。寻找规律并推广。

正常人的思路

https://www.jianshu.com/p/47435d902635
这个观点中利用了上一步骤中的matrix[i][j] = matrix[n - 1 - j][i]
发现是4个元素进行旋转的与我的结论一致。但我没有利用matrix[i][j] = matrix[n - 1 - j][i]直接由第一个点退出其他三个点。

最后四个循环元素中左上角的元素坐标规律为：
3 * 3 的矩阵，需要旋转2组元素，需要定位到 [0][0], [0][1] 4 * 4
的矩阵，需要旋转4组元素，需要定位到 [0][0], [0][1], [0][2], [1][1] 5 * 5
的矩阵，需要旋转6组元素，需要定位到 [0][0], [0][1], [0][2], [0][3], [1][1], [1][2]
https://www.jianshu.com/p/47435d902635

明显可得外层循序按for(int i = 0; i <n -2 ; i ++)
内层循环for(int j = i; j < n - 2i; j ++)

利用第一阶段思考的结果，使得归纳过程明显更为简洁。

大佬的思路

/*

• clockwise rotate
• first reverse up to down, then swap the symmetry
• 1 2 3 7 8 9 7 4 1
• 4 5 6 => 4 5 6 => 8 5 2
• 7 8 9 1 2 3 9 6 3
  */
  将matrix中行的顺序逆转后。只需将xy坐标轴对调。

代码

我的代码

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        int begin = 0;
        int x,y,temp,length,dx,dy;
        for(int d = n -1; d >= 1; d -= 2)
        {
            x = begin,y = begin;
            temp  = matrix[x][y];
            matrix[x][y] = matrix[x + d][y];
            x = x + d;
            matrix[x][y] = matrix[x][y + d];
            y = y + d;
            matrix[x][y] =  matrix[x - d][y];
            x = x - d;
            matrix[x][y] = temp;
            length = n - 1 - begin * 2;
            for(int dx = length - 1; dx >= 1; dx --)
            {
                
                dy = length - dx;
                x = begin,y = begin + dy;
                temp  = matrix[x][y];
                matrix[x][y] = matrix[x + dx][y - dy];
                x = x + dx, y = y - dy;
                matrix[x][y] = matrix[x + dy][y + dx];
                x = x + dy, y = y + dx;
                matrix[x][y] =  matrix[x - dx][y + dy];
                x = x - dx, y = y + dy;
                matrix[x][y] = temp;
            }
            begin ++;
        }
        
    }
};

根据坐标提示改后的代码

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        int x,y,nx,ny;
        for(int i = 0; i < n - 1; i ++)
        {
            for(int j = i; j < n - 1 - i; j ++)
            {
                x =  i,y = j;
                for(int k = 0; k < 3; k ++)
                { 
                    nx = n - 1- y,ny = x;
                    swap(matrix[x][y],matrix[nx][ny]);
                    x = nx,y = ny;
                }
            }
        }
        
    }
};

大佬的代码

void rotate(vector<vector<int> > &matrix) {
    reverse(matrix.begin(), matrix.end());
    for (int i = 0; i < matrix.size(); ++i) {
        for (int j = i + 1; j < matrix[i].size(); ++j)
            swap(matrix[i][j], matrix[j][i]);
    }
}

小结

每道题都有很多种做法。