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

题目

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

思路

一开始的状态总是往右走，接着往下走，再往左走，再往上走。这些移动可以把他们归为四个状态。我们需要新建一个跟原数组大小相同的数组，用来标记该位置是否被遍历过。

一旦遍历到边界或者该点被标记过了，我们就改变状态，即status=(status+1)%4;这样子，可保证循环下去，直到被所有点都被走完。

代码

//顺时针打印矩阵
class Solution {
    public int[] spiralOrder(int[][] matrix) {
        if (matrix.length==0 || matrix[0].length==0)
            return new int[0];
        int row=matrix.length;
        int colomn=matrix[0].length;

        //记录是否打印了
        boolean judge[][]=new boolean[row][colomn];
        for (int i=0;i<row;++i)
            for (int j=0;j<colomn;++j)
                judge[i][j]=false;

        int temp=row*colomn;
        int result[]=new int[temp];//结果数组

        int index=0;

        int move[][]={
                {0,1},//右
                {1,0},//下
                {0,-1},//左
                {-1,0} //上

        };

        int status=0;//初始状态 表示往右走
        int x=0;//初始横坐标
        int y=-1;//初始纵坐标
        int temp_x=0;
        int temp_y=0;
        while (index<temp)
        {
            temp_x=x+move[status][0];
            temp_y=y+move[status][1];
            if (temp_x > -1 && temp_x < row && temp_y > -1 && temp_y < colomn && !judge[temp_x][temp_y])
            {
                x=temp_x;
                y=temp_y;
                result[index]=matrix[x][y];//第一个位置
                judge[x][y]=true;
                ++index;
            }
            else //越界或者是走过了
            {
                status=(status+1)%4;
            }

        }
        return result;
    }
}

结果

是一道简单题，里面的状态转换是一个比较难以想的点，除此之外，没有啥难点了。

题解优秀思路

题解的另外一种思路是按层模拟。因为首先打印的是最外围的【即第一层】，然后再第二层，第三层，依次类推。。

每次循环后，把左右边界和上下边界的数值给响应的增加或者减少1，就不用多加一个判断数组了。

代码

class Solution {
    public int[] spiralOrder(int[][] matrix) {
    //防止行或者列长度为0
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return new int[0];
        }
        //记录行数和列数
        int rows = matrix.length, columns = matrix[0].length;
        //结果数组
        int[] order = new int[rows * columns];
        //结果数组下标
        int index = 0;
        int left = 0, right = columns - 1, top = 0, bottom = rows - 1;
        while (left <= right && top <= bottom) {
        //往右
            for (int column = left; column <= right; column++) {
                order[index++] = matrix[top][column];
            }
            //往下
            for (int row = top + 1; row <= bottom; row++) {
                order[index++] = matrix[row][right];
            }
            if (left < right && top < bottom) {
            //往左
                for (int column = right - 1; column > left; column--) {
                    order[index++] = matrix[bottom][column];
                }
                //往上
                for (int row = bottom; row > top; row--) {
                    order[index++] = matrix[row][left];
                }
            }
            left++;
            right--;
            top++;
            bottom--;
        }
        return order;
    }
}