【LeetCode】解题54：Spiral Matrix

Problem 54: Spiral Matrix [Medium]

Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.

Example 1:

Input:
[
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
]
Output: [1,2,3,6,9,8,7,4,5]

Example 2:

Input:
[
[1, 2, 3, 4],
[5, 6, 7, 8],
[9,10,11,12]
]
Output: [1,2,3,4,8,12,11,10,9,5,6,7]

来源：LeetCode

解题思路

将二维数组由外圈至里圈拆分，每个圈的起点正好位于matrix[i][i]，只需要写一个循环一圈的函数side_order()，然后选择不同的起点调用该函数，一共调用$\frac{\min (m,n)+1}{2}$次。

如下图所示：

红色为第一次调用side_order()函数，起始位置为(0,0)，蓝色为第二次调用，起始位置为(1,1)。

具体过程：

• 循环$\frac{\min (m,n)+1}{2}$次，每次选中的圈的四个顶点为：
  $top\_left=[side,side]，$
  $top\_right=[side,n-side-1]，$
  $bottom\_right=[m-side-1,n-side-1]，$
  $bottom\_left=[m-side-1,side]$
• 顺时针遍历四条边依次选入最终结果的点为
  [side, side ~ n-side-1]，
  [side+1 ~ m-side-1, n-side-1]，
  [m-side-1, n-side-2 ~ side]，
  [m-side-2 ~ side+1, side]
• 注意：当选中的圈的行数或列数为1时，需要及时结束函数，避免重复选入。

整个算法只遍历一次数组，时间复杂度为O(m*n)

运行结果：

Solution (Java)

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        int m = matrix.length;
        if(m == 0) return new ArrayList<Integer>();
        int n = matrix[0].length;
        List<Integer> result = new ArrayList<Integer>();
        int num = Math.min(m,n);
        for(int i = 0; i < (num+1)/2; i++){
            side_order(matrix, m, n, i, result);
        }
        return result;
    }

    private void side_order(int[][] matrix, int m, int n, int side, List<Integer> result){
        for(int j = side; j < n - side; j++){
            result.add(matrix[side][j]);
        }
        if(side + 1 >= m - side) return;
        for(int i = side+1; i < m - side; i++){
            result.add(matrix[i][n-side-1]);
        }
        if(n - side - 2 < side) return;
        for(int j = n - side - 2; j >= side; j--){
            result.add(matrix[m-side-1][j]);
        }
        for(int i = m - side - 2; i >= side+1; i--){
            result.add(matrix[i][side]);
        }
    }
}

修改过程

• 在函数side_order()中没有及时截断绕圈选点，导致会出现重复选入。
• 循环次数使用了$\frac{(m+1)}{2}$而没有选择$\frac{\min (m,n)+1}{2}$，导致行数大于列数时会出现数组溢出。