力扣59：螺旋矩阵 II 的Java解法（附带当矩阵是m*n时的解法）

题目描述

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

输入输出示例：

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

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

我的解法

• 初始化一个 n x n 的矩阵 res。
• 使用 start 变量记录当前螺旋矩阵的起始位置，loop 变量记录要进行的完整螺旋圈数（n / 2），count 变量记录当前要填入矩阵的值。
• 循环填充螺旋矩阵：
  • 依次从左到右、从上到下、从右到左、从下到上填充一圈元素。
  • 每填充完一圈后，更新 start 位置并减少 loop 次数。
• 如果 n 是奇数，最后填充矩阵中心的元素。
• 返回填充好的矩阵 res。

class Solution {
    public int[][] generateMatrix(int n) {
        // 初始化一个 n x n 的矩阵
        int[][] res = new int[n][n];
        // 初始化起始位置
        int start = 0;
        // 计算完整螺旋圈数
        int loop = n / 2;
        // 初始化当前要填入矩阵的值
        int count = 1;
        
        // 当 loop 大于 0 时，持续填充矩阵
        while (loop > 0) {
            // 初始化当前圈的起始位置
            int x = start;
            int y = start;
            
            // 从左到右填充当前上边界
            for (; y < n - start - 1; y++) {
                res[x][y] = count++;
            }
            // 从上到下填充当前右边界
            for (; x < n - start - 1; x++) {
                res[x][y] = count++;
            }
            // 从右到左填充当前下边界
            for (; y > start; y--) {
                res[x][y] = count++;
            }
            // 从下到上填充当前左边界
            for (; x > start; x--) {
                res[x][y] = count++;
            }
            
            // 更新起始位置
            start++;
            // 减少完整螺旋圈数
            loop--;
        }
        
        // 如果 n 是奇数，填充矩阵中心的元素
        if (n % 2 == 1) {
            res[start][start] = count;
        }
        
        // 返回填充完的矩阵
        return res;
    }
}

GPT解法

• 初始化一个 n x n 的矩阵 res，并设定初始值 count 为 1，表示当前要填入矩阵的值。
• 设置四个边界：上边界 top，下边界 bottom，左边界 left，右边界 right，初始时分别为 0，n-1，0，n-1。
• 通过四个方向（从左到右，从上到下，从右到左，从下到上）依次填充矩阵。
• 每次填充完一个方向后，更新相应的边界（例如从左到右填充完后，top 增加 1）。
• 重复以上步骤，直到 count 达到 n^2。

class Solution {
    public int[][] generateMatrix(int n) {
        // 初始化一个 n x n 的矩阵
        int[][] res = new int[n][n];
        // 初始化当前要填入矩阵的值
        int count = 1;
        // 初始化四个边界
        int top = 0, bottom = n - 1, left = 0, right = n - 1;
        
        // 当 count 小于等于 n^2 时，持续填充矩阵
        while (count <= n * n) {
            // 从左到右填充当前上边界
            for (int i = left; i <= right; i++) {
                res[top][i] = count++;
            }
            // 填充完上边界后，向下移动上边界
            top++;
            
            // 从上到下填充当前右边界
            for (int i = top; i <= bottom; i++) {
                res[i][right] = count++;
            }
            // 填充完右边界后，向左移动右边界
            right--;
            
            // 从右到左填充当前下边界
            for (int i = right; i >= left; i--) {
                res[bottom][i] = count++;
            }
            // 填充完下边界后，向上移动下边界
            bottom--;
            
            // 从下到上填充当前左边界
            for (int i = bottom; i >= top; i--) {
                res[i][left] = count++;
            }
            // 填充完左边界后，向右移动左边界
            left++;
        }
        
        // 返回填充完的矩阵
        return res;
    }
}

当矩阵是m*n时

class Solution {
    public int[][] generateMatrix(int m, int n) {
        // 初始化一个 m x n 的矩阵
        int[][] res = new int[m][n];
        // 初始化当前要填入矩阵的值
        int count = 1;
        // 初始化四个边界
        int top = 0, bottom = m - 1, left = 0, right = n - 1;

        // 当 count 小于等于 m * n 时，持续填充矩阵
        while (count <= m * n) {
            // 从左到右填充当前上边界
            for (int i = left; i <= right && count <= m * n; i++) {
                res[top][i] = count++;
            }
            // 填充完上边界后，向下移动上边界
            top++;

            // 从上到下填充当前右边界
            for (int i = top; i <= bottom && count <= m * n; i++) {
                res[i][right] = count++;
            }
            // 填充完右边界后，向左移动右边界
            right--;

            // 从右到左填充当前下边界
            for (int i = right; i >= left && count <= m * n; i--) {
                res[bottom][i] = count++;
            }
            // 填充完下边界后，向上移动下边界
            bottom--;

            // 从下到上填充当前左边界
            for (int i = bottom; i >= top && count <= m * n; i--) {
                res[i][left] = count++;
            }
            // 填充完左边界后，向右移动左边界
            left++;
        }

        // 返回填充完的矩阵
        return res;
    }
}

本地运行main

package qes59;

public class Main {
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] result = sol.generateMatrix(7, 8);
        for (int[] row : result) {
            for (int num : row) {
                System.out.print(num + "\t");
            }
            System.out.println();
        }
    }
}