Leecode 矩阵

73. 矩阵置0

 思路：

1. 检查第一行和第一列是否需要被设为0：如果第一行或第一列中有任何元素为0，则将相应的标记设置为true。

2. 使用第一行和第一列记录其他行和列：遍历矩阵的其余部分，并使用第一行和第一列来记录是否需要将整行或整列设为0。

3. 设置0到其他行和列：根据第一行和第一列的标记，设置其他行和列的0。

4. 根据标记设置第一行和第一列：如果第一行或第一列的标记为true，则将整行或整列设为0。

class Solution {
    public void setZeroes(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        boolean firstRowZero = false, firstColZero = false;

        // 检查第一行是否需要被设为0
        for (int j = 0; j < n; j++) {
            if (matrix[0][j] == 0) {
                firstRowZero = true;
                break;
            }
        }

        // 检查第一列是否需要被设为0
        for (int i = 0; i < m; i++) {
            if (matrix[i][0] == 0) {
                firstColZero = true;
                break;
            }
        }

        // 使用第一行和第一列记录其他行和列
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][j] == 0) {
                    matrix[i][0] = 0;
                    matrix[0][j] = 0;
                }
            }
        }

        // 设置0到其他行和列，注意从1开始
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
                    matrix[i][j] = 0;
                }
            }
        }

        // 根据标记设置第一行
        if (firstRowZero) {
            for (int j = 0; j < n; j++) {
                matrix[0][j] = 0;
            }
        }

        // 根据标记设置第一列
        if (firstColZero) {
            for (int i = 0; i < m; i++) {
                matrix[i][0] = 0;
            }
        }
    }
}

54. 螺旋矩阵

思路：

1. 定义边界: 定义四个边界，即左、右、上、下边界，用于限制遍历的范围。
2. 顺时针遍历:
   • 从左到右遍历上边界。
   • 从上到下遍历右边界。
   • 从右到左遍历下边界（如果还没有缩小到一行）。
   • 从下到上遍历左边界（如果还没有缩小到一列）。
3. 缩小边界: 完成一次完整的顺时针遍历后，缩小边界。
4. 重复步骤2和3: 直到边界相交或者越过。

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        if (matrix == null || matrix.length == 0) return result;

        int m = matrix.length, n = matrix[0].length;
        int left = 0, right = n - 1, top = 0, bottom = m - 1;

        while (left <= right && top <= bottom) {
            // 从左到右遍历上边界
            // 注意是<=,要有=
            for (int j = left; j <= right; j++) {
                result.add(matrix[top][j]);
            }
            // 从上到下遍历右边界
            for (int i = top + 1; i <= bottom; i++) {
                result.add(matrix[i][right]);
            }
            // 从右到左遍历下边界
            // 注意要有if
            if (top < bottom) {
                for (int j = right - 1; j >= left; j--) {
                    result.add(matrix[bottom][j]);
                }
            }
            // 从下到上遍历左边界
            if (left < right) {
                for (int i = bottom - 1; i > top; i--) {
                    result.add(matrix[i][left]);
                }
            }
            // 缩小边界
            left++;
            right--;
            top++;
            bottom--;
        }

        return result;
    }
}

if (top < bottom) 确保我们只有在上下边界不在同一行时才遍历下边界。如果它们在同一行，那么下边界的遍历将被跳过，从而避免了重复访问。

考虑下面这个例子：

[[1, 2, 3]]