矩阵-模拟

566. 重塑矩阵

思路：

• 首先，判断重塑尺寸是否合法，若不合法 --> 则直接返回原数组；
• 维护一个下标 index 记录当前填充到“新数组”的第 index 个元素了；
• 遍历“旧数组”，且新、老数组下标关系为：
  • row = index / c;
  • col = index % c;

class Solution {
    public int[][] matrixReshape(int[][] mat, int r, int c) {
        if (mat.length == 0) {
            return new int[][] {};
        }
        int m = mat.length;
        int n = mat[0].length;
        // 重塑尺寸不合法 --> 返回原数组
        if (m * n != r * c) {
            return mat;
        }
        int index = 0;
        int[][] res = new int[r][c];
        for (int i = 0; i < m; i++) {
            for (int j  = 0; j < n; j++) {
                int row = index / c;
                int col = index % c;
                res[row][col] = mat[i][j];
                index++;
            }
        }
        return res;
    }
}

• 时间复杂度：$O(m\ast n)$
• 时间复杂度：$O(1)$ （这里指的是额外的辅助空间，不包括res空间）

867. 转置矩阵

思路：

• 矩阵转置 --> 遍历转置前的矩阵，直接将转置前后的矩阵“行、列索引交换”，即可

class Solution {
    public int[][] transpose(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] res = new int[n][m];
        // 枚举matrix行       
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                res[j][i] = matrix[i][j]; // 对角线翻转
            }
        }
        return res;
    }
}

• 时间复杂度：$O(m\ast n)$
• 时间复杂度：$O(1)$ （这里指的是额外的辅助空间，不包括res空间）

59. 螺旋矩阵 II

思路：🤔

• 一共需要“转圈圈”的圈数为 loop = n / 2 圈
• 每一圈的其实位置为 i = startX、j = startY;
• 所有区间均采用 左闭右开 区间
• 若 $n$ 为奇数，则最中间一个元素，需要单独处理。

以 $n=5$ 为例，填充区间 边界处理，如下图：

class Solution {
    public int[][] generateMatrix(int n) {
        int index = 1;
        int startX = 0;
        int startY = 0;
        int i = startX;
        int j = startY;
        int loop = n / 2;
        int[][] matrix = new int[n][n];
        while (loop-- > 0) {
            i = startX;
            j = startY;
            // 上面：左闭右开
            for ( ; j < n - startY - 1; j++) {
                matrix[i][j] = index++;
            }
            // 右面：左闭右开
            for ( ; i < n - startX - 1; i++) {
                matrix[i][j] = index++;
            }
            // 下面：左闭右开
            for ( ; j > startY; j--) {
                matrix[i][j] = index++;
            }
            // 左面：左闭右开
            for ( ; i > startX ; i--) {
                matrix[i][j] = index++;
            }
            // 更新
            startX++;
            startY++;
        }
        // 奇数，中间一个元素单独处理
        if (n % 2 == 1) {
            matrix[n / 2][n  / 2] = index++;
        }
        return matrix;
    }
}

• 时间复杂度：$O(n^2)$
• 时间复杂度：$O(1)$ （这里指的是额外的辅助空间，不包括matrix空间）
  

54. 螺旋矩阵 ⭐️

my code

思路：

• 仍然按照 59. 螺旋矩阵 II 思路模拟，但是由于本题中 “m 和 n 不一定相等”，所以用此种方法的话，较之 59. 螺旋矩阵 II 复杂

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> res = new ArrayList<>();
        int startX = 0;
        int startY = 0;
        int i = startX;
        int j = startY;
        int m = matrix.length;
        int n = matrix[0].length;
        int loopRow = m / 2;
        int loopCol = n / 2;
        System.out.println("loopRow = " + loopRow);
        System.out.println("loopCol = " + loopCol);
        while (loopRow-- > 0 && loopCol-- > 0) {
            i = startX;
            j = startY;
            // 上面：左闭右开
            for ( ; j < n - startY - 1; j++) {
                res.add(matrix[i][j]);
            }
            // 右面：左闭右开
            for ( ; i < m - startX - 1; i++) {
                res.add(matrix[i][j]);
            }
            // 下面：左闭右开
            for ( ; j > startY; j--) {
                res.add(matrix[i][j]);
            }
            // 左面：左闭右开
            for ( ; i > startX ; i--) {
                res.add(matrix[i][j]);
            }
            // 更新
            startX++;
            startY++;
        }
        // 保证下面奇数、偶数中间行处理的逻辑if只能进去一个
        boolean flag = false;
        // 行数为奇数（且）时，最中间的一排单独处理 --> 此时，不管列数是奇数还是偶数，都不必进入下面“单独处理奇数中间列的if”
        if (m % 2 == 1) { // 优先“行”，
            i = startX;
            j = startY;
            // 左闭右开
            for ( ; j < n - startY - 1; j++) {
                flag = true;
                res.add(matrix[i][j]);
            }
        }
        // 列数为奇数时，最中间的一列单独处理
        if ( n % 2 == 1 && !flag) {
            i = startX;
            j = startY;
            // 左闭右开
            for ( ; i < m - startX - 1; i++) {
                res.add(matrix[i][j]);
            }
        }
        // 最后一个元素
        if (res.size() < m * n) {
            res.add(matrix[i][j]);
        }
        return res;
    }
}

注意：

• 当行数、列数为奇数时，中间一行、或中间一列 需要单独处理！
  • 单独处理中间行、中间列的逻辑只能进入一个！！！
• 所有区间均采用“左闭右开”区间。

73. 矩阵置零

空间 $O(m+n)$

思路：

• 使用两个数组 rows、cols，分别记录 $matrix$ 记录 行、列 出现 0 的情况；
• 遍历 $matrix$，将 rows、cols 标记为 true 的行、列全部置为零。

class Solution {
    public void setZeroes(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        boolean[] rows = new boolean[m];
        boolean[] cols = new boolean[n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == 0) {
                    rows[i] = true;
                    cols[j] = true;
                }
            }
        }
        // 行置零
        for (int i = 0; i < m; i++) {
            if (rows[i]) {
                for (int j = 0; j < n; j++) {
                    matrix[i][j] = 0;
                }
            }
        }
        // 列置零
        for (int j = 0; j < n; j++) {
            if (cols[j]) {
                for (int i = 0; i < m; i++) {
                    matrix[i][j] = 0;
                }
            }
        }
    }
}

• 时间复杂度：$O(n^2)$
• 时间复杂度：$O(m+n)$

原地算法 ⭐️ （空间复杂度 $O(1)$）

…