数组——螺旋矩阵

螺旋矩阵

参考链接

螺旋矩阵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

要点：n x n 矩阵

1. 循环起始位置：主对角线上的元素
2. 循环次数：具有对称性，只需循环n / 2次，奇数n相较于偶数n，需要填充中心点(n / 2, n / 2)坐标
3. 每一条边的填充，都坚持左开右闭
4. 画示意图，确定每条边上每个小框的坐标位置。
   

Java代码如下：

class Solution {
    public int[][] generateMatrix(int n) {
        /**定义每次循环的起始位置(startPos, startPos)*/
        int startPos = 0;
        /**控制自循环次数*/
        int loop = 0;
        /**定义返回的二维数组*/
        int[][] result = new int[n][n];
        /**定义初始填充值*/
        int count = 1;
        /**定义填充坐标i,j*/
        int i, j ;

        /**开始模拟，确定边界，loop从1开始，每条边都按左闭右开去遍历*/
        while (loop++ < n / 2) {
            /**由于是正方形矩阵，具有对称性，无论n为奇还是偶，都需循环n / 2次，奇数需要在正中心(n / 2, n / 2)填充n^2值*/
            /**模拟上侧从左到右*/
            for (j = startPos; j < n - loop; j++) {
                result[startPos][j] = count++;
            }
            /**模拟右侧从上到下*/
            for (i = startPos; i < n - loop; i++) {
                result[i][j] = count++;
            }
            /**模拟下侧从右到左*/
            for (; j > startPos; j--) {
                result[i][j] = count++;
            }
            /**模拟左侧从下到上*/
            for (; i > startPos; i--) {
                result[i][j] = count++;
            }
            startPos++;
        }
        if (n % 2 == 1) {
            result[n / 2][n / 2] = count;
        }
        return result;
    }
}

JavaScript代码如下：

/**
 * @param {number} n
 * @return {number[][]}
 */
var generateMatrix = function(n) {
    let startPos = 0,
        loop = 0,
        result = new Array(n).fill(0).map(() => new Array(n).fill(0)),
        count = 1,
        i, j;
    while (loop++ < n / 2) {
        for (j = startPos; j < n - loop; j++) {
            result[startPos][j] = count++;
        }
        for (i = startPos; i < n - loop; i++) {
            result[i][j] = count++;
        }
        for (; j > startPos; j--) {
            result[i][j] = count++;
        }
        for (; i > startPos; i--) {
            result[i][j] = count++;
        }
        startPos++;
    }
    if (n % 2 == 1) {
        mid = Math.floor(n / 2);
        result[mid][mid] = count;
    }
    return result;
};

Python代码如下：

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        startPos = 0
        count = loop = 1
        result = [[0] * n for i in range(n)]

        while loop <= n // 2:
            for j in range(startPos, n - loop):
                result[startPos][j] = count
                count += 1
            for i in range(startPos, n - loop):
                result[i][n - loop] = count
                count += 1
            for j in range(n - loop, startPos, -1):
                result[n - loop][j] = count
                count += 1
            for i in range(n - loop, startPos, -1):
                result[i][startPos] = count
                count += 1
            loop += 1
            startPos += 1
        if n % 2 == 1:
            result[n // 2][n // 2] = count
        return result

---

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

这里专门分析一下列长和行长最小值可以被2整除2的情况：循环后无需再做任何处理。

Python代码如下：

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        rowLen, colLen, startPos =len(matrix[0]), len(matrix), 0
        loop = 1
        result = []
        while loop <= min(rowLen, colLen) // 2:
            for j in range(startPos, rowLen - loop):
                result.append(matrix[startPos][j])
            for i in range(startPos, colLen - loop):
                result.append(matrix[i][rowLen - loop])
            for j in range(rowLen - loop, startPos, -1):
                result.append(matrix[colLen - loop][j])
            for i in range(colLen - loop, startPos, -1):
                result.append(matrix[i][startPos])
            loop += 1
            startPos += 1
        """这里需要注意：如果min(列长，行长)可以整除2的话，那么就不需要再做处理了"""
        if min(rowLen, colLen) % 2 == 1:
            if rowLen == min(rowLen, colLen):
                for i in range(startPos, colLen - loop + 1):
                    result.append(matrix[i][startPos])
            elif colLen == min(rowLen, colLen):
                for j in range(startPos, rowLen - loop + 1):
                    result.append(matrix[startPos][j])
        return result