力扣100题解及笔记 矩阵

73.矩阵置零

给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。


提示：

m == matrix.length
n == matrix[0].length
1 <= m, n <= 200
-231 <= matrix[i][j] <= 231 - 1
 

进阶：

一个直观的解决方案是使用  O(mn) 的额外空间，但这并不是一个好的解决方案。
一个简单的改进方案是使用 O(m + n) 的额外空间，但这仍然不是最好的解决方案。
你能想出一个仅使用常量空间的解决方案吗？

标记需要置零的行和列，再遍历置零，避免重复

class Solution {
    public void setZeroes(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        boolean[] rowFlags = new boolean[m];
        boolean[] colFlags = new boolean[n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == 0) {
                    rowFlags[i] = true;
                    colFlags[j] = true;
                }
            }
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (rowFlags[i] || colFlags[j]) {//是或
                    matrix[i][j] = 0;
                }
            }
        }
    }
}

54.螺旋矩阵

54. 螺旋矩阵

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。


提示：

m == matrix.length
n == matrix[i].length
1 <= m, n <= 10
-100 <= matrix[i][j] <= 100

四个指针分别跟踪当前层的上、下、左、右边界的移动

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        if (matrix.length == 0) return new ArrayList<Integer>();
        // l: 左边界 (left)
        // r: 右边界 (right)
        // t: 上边界 (top)
        // b: 下边界 (bottom)
        // x: 当前结果数组的索引
        int l = 0, r = matrix[0].length - 1, t = 0, b = matrix.length - 1, x = 0;
        Integer[] res = new Integer[(r + 1) * (b + 1)];

        while (true) {
            // 从左到右遍历当前最上面的行（由上边界 t 和左右边界 l 和 r 决定）
            for (int i = l; i <= r; i++) res[x++] = matrix[t][i]; 
            // 移动上边界，如果上边界大于下边界，则遍历结束
            if (++t > b) break;
            // 从上到下遍历当前最右边的列（由右边界 r 和上下边界 t 和 b 决定）
            for (int i = t; i <= b; i++) res[x++] = matrix[i][r];
            // 移动右边界，如果左边界大于右边界，则遍历结束
            if (l > --r) break;
            // 从右到左遍历当前最下面的行（由下边界 b 和左右边界 l 和 r 决定）
            for (int i = r; i >= l; i--) res[x++] = matrix[b][i]; 
            // 移动下边界，如果上边界大于下边界，则遍历结束
            if (t > --b) break;
            // 从下到上遍历当前最左边的列（由左边界 l 和上下边界 t 和 b 决定）
            for (int i = b; i >= t; i--) res[x++] = matrix[i][l]; 
            // 移动左边界，如果左边界大于右边界，则遍历结束
            if (++l > r) break;
        }
        return Arrays.asList(res);
    }
}

48.旋转图像

48. 旋转图像

定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。



提示：

n == matrix.length == matrix[i].length
1 <= n <= 20
-1000 <= matrix[i][j] <= 1000

class Solution {
    public void rotate(int[][] matrix) {
        int n = matrix.length;
        // 外层循环：只需要遍历一半的层，旋转会同时影响对称的层
        for (int i = 0; i < n / 2; i++) {
            // 内层循环：遍历当前层的前半部分列，j 是列索引
            for (int j = 0; j < (n + 1) / 2; j++) {
                int tmp = matrix[i][j];
                // 进行四次旋转，将四个对应的元素依次交换
                // 将左下角的元素移动到左上角
                matrix[i][j] = matrix[n - 1 - j][i];
                // 将右下角的元素移动到左下角
                matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j];
                // 将右上角的元素移动到右下角
                matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i];
                // 将临时存储的左上角的元素移动到右上角
                matrix[j][n - 1 - i] = tmp;
            }
        }
    }
}

240.二维矩阵2

240. 搜索二维矩阵 II

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：

每行的元素从左到右升序排列。
每列的元素从上到下升序排列。
 

提示：

m == matrix.length
n == matrix[i].length
1 <= n, m <= 300
-109 <= matrix[i][j] <= 109
每行的所有元素从左到右升序排列
每列的所有元素从上到下升序排列
-109 <= target <= 109

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        // i: 当前搜索的行索引，初始值为最后一行
        int i = matrix.length - 1;
        // j: 当前搜索的列索引，初始值为第一列
        int j = 0;
        // 开始从矩阵的左下角向右上角搜索
        while (i >= 0 && j < matrix[0].length) {
            // 如果当前元素大于目标值，则向上移动一行
            if (matrix[i][j] > target)  i--;
            // 如果当前元素小于目标值，则向右移动一列
            else if (matrix[i][j] < target) j++;
            else return true;
        }
        return false;
    }
}

类似二叉搜索树