剑指 Offer 29. 顺时针打印矩阵（模拟迭代）

剑指 Offer 29. 顺时针打印矩阵

问题描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

示例 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]

限制：

    0 <= matrix.length <= 100
    0 <= matrix[i].length <= 100

解题思路

本题按照顺时针进行元素的遍历，主要思路为：

根据矩阵的行数m和列数n确定顺时针方向的边界（left，right，up，bottom）。

每一轮的方向为：

1. 先向右走，走到右边界处，开始向下走，更新上边界（此时最上面的一行元素已遍历完，因此需要把up++，即上边界下移一层）；
2. 向下走，走到下边界处，开始向左走，更新右边界（此时最右面的一列元素已遍历完，因此需要把right--，即右边界左移一层）；
3. 向左走，走到左边界处，开始向上走，更新下边界（此时最下面的一行元素已遍历完，因此需要把bottom--，即上边界上移一层）；
4. 向上走，走到上边界处，开始向右走，更新左边界（此时最左面的一列元素已遍历完，因此需要把left++，即左边界右移一层）。

循环以上过程直到左右边界重合，或者元素已被遍历完（结果数组下标>=n*m），跳出循环，输出结果即可。

（还有另一种解法，适合方向更多的时候使用，就是使用flag数组标记一下是否被遍历过。直到遍历过元素数量=n*m即可）

Java解法

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        if(matrix.length==0) return new int []{};
        int m=matrix.length,n=matrix[0].length;
        int [] res = new int [n*m]; 
        helper(matrix,res,n-1,m-1,0,0,n,m);
        return res;
    }
    public void helper(int [][] matrix,int [] res,int right,int bottom,int left,int up,int n,int m){
        int k=0;
        while(left<=right && up<=bottom){
            if(k<n*m){
                for(int i=left;i<=right;i++){
                    res[k++]=matrix[up][i];
                }
                up++;
            }else break;
            if(k<n*m){
                for(int i=up;i<=bottom;i++){
                    res[k++]=matrix[i][right];
                }
                right--;
            }else break;
            if(k<n*m){
                for(int i=right;i>=left;i--){
                    res[k++]=matrix[bottom][i];
                }
                bottom--;
            }else break;
            
            if(k<n*m){
                for(int i=bottom;i>=up;i--){
                    res[k++]=matrix[i][left];
                }
                left++;
            }else break;
        }
    }
}