剑指 offer29 顺时针打印矩阵

剑指 offer 29 顺时针打印矩阵

方法一

class Solution {
    public int[] spiralOrder(int[][] matrix) {
       
        int row = matrix.length;
        if(row<=0){
            return new int[0];
        }
        int colum = matrix[0].length;
        if(colum<=0){
            return new int[0];
        }
        int[] res = new int[row*colum];
        int start=0;
        int index=0;
        while(row>start *2 && colum>start*2){

            index = PrintMatrixInCircle(matrix,res,start,index);
            start++;
        }
        return res;
    }

    private int PrintMatrixInCircle(int[][] matrix,int[] res,int start,int index){
        int row = matrix.length;
        int colum = matrix[0].length;
        int endX = colum-1-start;
        int endY = row-1-start;
        //从左到右
        // int index = start*colum+start;
        for(int i=start;i<=endX;i++){
            res[index] = matrix[start][i];
            index++;
        }
        //从上到下 至少两行，因为从左到右肯定占一行
        if(endY>start){
            for(int i=start+1;i<=endY;i++){
                res[index] = matrix[i][endX];
                index++;
            }
        }
        //从右到左，至少两行，至少两列，因为从上到下占一列
        if(endX>start && endY>start){
            for(int i=endX-1;i>=start;i--){
                res[index] = matrix[endY][i];
                index++;
            }
        }
        //从下到上，至少两列，至少三行，因为从左到右，从右到左占两行
        if(endX>start && endY>start+1){
            for(int i = endY-1; i>start;i--){
                res[index] = matrix[i][start];
                index++;
            }
        }
        return index;
    }
}

时间复杂度$O(mn)$，$m$，$n$分别是矩阵的行数和列数，矩阵所有元素需要遍历一遍。
空间复杂度$O(1)$，除了输出数组以外，空间复杂度是常数。

方法二

模拟打印矩阵的路径。初始位置是矩阵的左上角，初始方向是向右，当路径超出界限或者进入之前访问过的位置，顺时针旋转，进入下一个方向。
判断路径是否进入之前访问过的位置需要使用一个与输入矩阵大小相同的辅助矩阵visit ，其中的每个元素表示该位置是否被访问过。当一个元素被访问时，将 visit 中的对应位置的元素设为已访问。
如何判断路径是否结束？由于矩阵中的每个元素都被访问一次，因此路径的长度就是矩阵中元素的数量，当路径长度达到矩阵中的元素数量时就是完整路径，将该路径返回。

class Solution {
    //int[][] directions = {{0,1},{1,0},{0,-1},{-1,0}};
    public int[] spiralOrder(int[][] matrix) {
        if(matrix == null || matrix.length==0 || matrix[0].length==0){
            return new int[0];
        }
        int rows = matrix.length;
        int columns = matrix[0].length;
        int[][] visit = new int[rows+1][columns+1];
        int len = rows*columns;
        int[] res = new int[len];
        int x = 0;
        int y = -1;
        int i = 0;
        while(i<len){
            while(y+1<columns && visit[x][y+1]==0 ){
                //没被访问过 向右走
                // x = x + directions[0][0];
                y = y + 1;
                res[i] = matrix[x][y];
                visit[x][y] = 1;
                i++;
            }
            //从上到下
            while(x+1<rows && visit[x+1][y] == 0 ){
                x = x + directions[1][0];
                // y = y + directions[1][1];
                res[i] = matrix[x][y];
                visit[x][y] = 1;
                i++;
            }
            //从右到左
            while(y-1>=0 && visit[x][y-1] == 0 ){
                // x = x + directions[2][0];
                y = y -1;
                res[i] = matrix[x][y];
                visit[x][y] = 1;
                i++;
            }
            //从下到上
            while(x-1 >=0 && visit[x-1][y] == 0){
                x = x -1;
                // y = y + directions[3][1];
                res[i] = matrix[x][y];
                visit[x][y] = 1;
                i++;
            }
        }
        return res;
    }
}

时间复杂度$O(mn)$。
空间复杂度$O(mn)$，需要一个大小是$m\ast n$的矩阵 visit 来记录每个元素是否被访问过。