代码随想录 数组-05-螺旋矩阵

坚持循环不变量原则

模拟顺时针画矩阵的过程:

• 填充上行从左到右
• 填充右列从上到下
• 填充下行从右到左
• 填充左列从下到上

由外向内一圈一圈这么画下去。

这里一圈下来，我们要画每四条边，这四条边怎么画，每画一条边都要坚持一致的左闭右开

54.螺旋矩阵

54. 螺旋矩阵

中等

提示

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

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

提示：

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

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        int m = matrix.length;      // 获取矩阵的行数
        int n = matrix[0].length;   // 获取矩阵的列数
        int max = Math.max(m, n);   // 获取行列中的较大值
        int min = Math.min(m, n);   // 获取行列中的较小值
        boolean judge = m > n;      // 判断行数是否大于列数
        
        List<Integer> result = new ArrayList<>();  // 用于存储螺旋遍历结果的列表
        int line = 0;                // 当前遍历的行
        int column = 0;              // 当前遍历的列
        int loop = 0;                // 外层循环的计数器，表示当前遍历的层数

        // 外层循环，每次循环遍历一个环
        while ((loop++ < min / 2)){
            // 从左到右沿顶部行遍历
            for (; column < n - loop; column++){
                result.add(matrix[line][column]);
            }
            
            // 从上到下沿右侧列遍历
            for (; line < m - loop; line++){
                result.add(matrix[line][column]);
            }
            
            // 从右到左沿底部行遍历
            for (; column >= loop; column--){
                result.add(matrix[line][column]);
            }
            
            // 从下到上沿左侧列遍历
            for (; line >= loop; line--){
                result.add(matrix[line][column]);
            }
            
            // 移动到矩阵的下一个内层
            line++;
            column++;
        }

        //处理最后一个单行或者单列的情况
        if (min % 2 == 1){
            if (judge){
                //剩余一列，从上到下遍历
                while (line <= m - loop){
                   result.add(matrix[line++][column]);
                }
            } else {
                //剩余一行，从左到右遍历
                while (column <= n - loop){
                    result.add(matrix[line][column++]);
                }
            }
        }
        return result;      //返回螺旋遍历结果
    }
}

59.螺旋矩阵II

59. 螺旋矩阵 II

中等

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

示例 1：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入：n = 1
输出：[[1]]

提示：

• 1 <= n <= 20

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] result = new int[n][n];  // 创建一个n x n的矩阵，用于存储生成的螺旋矩阵
        int loop = 0;                   // 外层循环的计数器，表示当前生成的层数
        int count = 1;                  // 用于填充矩阵的数值，初始为1
        int line = 0;                   // 当前填充的行
        int column = 0;                 // 当前填充的列

        // 外层循环，每次循环生成一个环
        while (loop++ < n / 2) {
            // 从左到右沿顶部行填充
            for (; column < n - loop; column++) {
                result[line][column] = count++;
            }

            // 从上到下沿右侧列填充
            for (; line < n - loop; line++) {
                result[line][column] = count++;
            }

            // 从右到左沿底部行填充
            for (; column >= loop; column--) {
                result[line][column] = count++;
            }

            // 从下到上沿左侧列填充
            for (; line >= loop; line--) {
                result[line][column] = count++;
            }

            // 移动到矩阵的下一个内层
            line++;
            column++;
        }

        // 处理最中心的单元格，当n为奇数时
        if (n % 2 == 1) {
            result[line][column] = count++;
        }

        return result;  // 返回生成的螺旋矩阵
    }
}

 LCR 146.螺旋遍历二维数组

LCR 146. 螺旋遍历二维数组

简单

给定一个二维数组 array，请返回「螺旋遍历」该数组的结果。

螺旋遍历：从左上角开始，按照 向右、向下、向左、向上 的顺序 依次 提取元素，然后再进入内部一层重复相同的步骤，直到提取完所有元素。

示例 1：

输入：array = [[1,2,3],[8,9,4],[7,6,5]]
输出：[1,2,3,4,5,6,7,8,9]

示例 2：

输入：array  = [[1,2,3,4],[12,13,14,5],[11,16,15,6],[10,9,8,7]]
输出：[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]

限制：

• 0 <= array.length <= 100
• 0 <= array[i].length <= 100

class Solution {
    public int[] spiralArray(int[][] array) {
        if (array == null || array.length == 0 || array[0].length == 0) {
            return new int[0];
        }

        int m = array.length;      // 获取矩阵的行数
        int n = array[0].length;   // 获取矩阵的列数
        int min = Math.min(m, n);   // 获取行列中的较小值
        boolean judge = m > n;      // 判断行数是否大于列数
        
        int[] result = new int[m * n];  // 用于存储螺旋遍历结果的数组
        int line = 0;                // 当前遍历的行
        int column = 0;              // 当前遍历的列
        int loop = 0;                // 外层循环的计数器，表示当前遍历的层数
        int index = 0;              //结果数组的索引 

        // 外层循环，每次循环遍历一个环
        while ((loop++ < min / 2)){
            // 从左到右沿顶部行遍历
            for (; column < n - loop; column++){
                result[index++] = array[line][column];
            }
            
            // 从上到下沿右侧列遍历
            for (; line < m - loop; line++){
                result[index++] = array[line][column];
            }
            
            // 从右到左沿底部行遍历
            for (; column >= loop; column--){
                result[index++] = array[line][column];
            }
            
            // 从下到上沿左侧列遍历
            for (; line >= loop; line--){
                result[index++] = array[line][column];
            }
            
            // 移动到矩阵的下一个内层
            line++;
            column++;
        }

        //处理最后一个单行或者单列的情况
        if (min % 2 == 1){
            if (judge){
                //剩余一列，从上到下遍历
                while (line <= m - loop){
                   result[index++] = array[line++][column];
                }
            } else {
                //剩余一行，从左到右遍历
                while (column <= n - loop){
                    result[index++] = array[line][column++];
                }
            }
        }
        return result;      //返回螺旋遍历结果
    }
}