顺时针打印矩阵

此处给出两种方法

方法一：

按题目所述，顺时针读取，按照读取行，读取列，反向读取行，反向读取列的顺序将整个矩阵存入结果数组中，采用这种方式时需要分别定义行与列的上下界。

public int[] printMatrix(int[][] matrix){
        //若传进来的二维数组为空则直接返回一个空数组
        if ((matrix==null||matrix.length==0)||(matrix.length==1&&matrix[0].length==0)){
            int[] a = new int[0];
            return a;
        }else {
            //定义一维数组用以存储输出的数据，长度为矩阵的总内容长度
            int[] arr = new int[matrix.length*matrix[0].length];
            try{
                //定义列的下界
                int min_columns=0;
                //定义行的下界
                int min_rows=0;
                //定义列上界
                int max_columns=matrix[0].length;
                //定义行上界
                int max_rows=matrix.length;
                //定义行列的初始位置
                int r=0;
                int c=0;
                //定义一维数组起始位置
                int i=0;
                //对矩阵进行扫描，结束时间为一维数组被填满（由于while判断条件是否满足在循环体全部执行完后，故次结束时间并不会真正生效）
                while (i<(matrix.length*matrix[0].length)){
                    //进行行扫描，在列到达列上界时结束，扫描结束后将行下界加一，列位置回退一格保证不会数组越界，将新行的起始位置定为行下界
                    while (c<max_columns){
                        arr[i]=matrix[r][c];
                        c++;
                        i++;
                    }
                    min_rows++;
                    c--;
                    r=min_rows;
                    //进行列扫描，在行到达行上界时结束，扫描结束后将列上界减一，行位置回退一格保证不会数组越界，将新列的起始位置定为列上界减一
                    while (r<max_rows){
                        arr[i]=matrix[r][c];
                        r++;
                        i++;
                    }
                    max_columns--;
                    r--;
                    c=max_columns-1;
                    //进行反向行扫描，在列到达列下界时结束，扫描结束后将行上界减一，列位置后移一格防止空指针，将新行的起始位置定为列下界
                    while (c>min_columns){
                        arr[i]=matrix[r][c];
                        c--;
                        i++;
                    }
                    max_rows--;
                    c++;
                    c=min_columns;
                    //进行反向列扫描，在行到达行下界时结束，扫描结束后将列上界加一，行位置后移一格防止空指针，将新列的起始位置定为行下界
                    while (r>min_rows){
                        arr[i]=matrix[r][c];
                        r--;
                        i++;
                    }
                    min_columns++;
                    r++;
                    r=min_rows;
                }
                //结束条件判断，即向结果数组中填入了超界的数据，自动返回结果数组
            }catch (ArrayIndexOutOfBoundsException arrayIndexOutOfBoundsException){
                return arr;
            }
            return arr;
        }
    }

 此为该代码执行效率

方法二：

根据题意得出，顺时针读取即将该矩阵“削皮”，那么容易想到读取完第一行后，将矩阵逆时针旋转，使原本的列变为行，行变为列，再次读取新矩阵的第一行，重复操作直到完成。由于Java没有自带的扭转矩阵数组方法，因此该方法需要自定义

public class Solution {
    public int[] spiralOrder(int[][] matrix) {
        //判空，直接返回
        if ((matrix==null||matrix.length==0)||(matrix.length==1&&matrix[0].length==0)){
            int[] a = new int[0];
            return a;
        }else {
            //定义结果数组起始位置
            int a = 0;
            //定义最大长度
            int max = matrix.length*matrix[0].length;
            int[] arr = new int[matrix.length*matrix[0].length];
            //未填满则继续
            while (a<max){
                //读入第一行内容
                for (int i=0;i<matrix[0].length;i++){
                    arr[a]=matrix[0][i];
                    a++;
                }
                //扭转数组
                matrix=ma(matrix);
            }
            return arr;
        }
    }

    public int[][] ma(int[][] arr){
        //定义新数组的起始位置
        int x=0;
        int y=0;
        //定义新数组，新行为旧列值，新列值为旧行值减一（抛弃旧数组第一行内容）
        int[][] ar = new int[arr[0].length][arr.length-1];
        //赋值，按列获取，将当前列内容依次转为新数组的行内容
        for (int i=arr[0].length-1;i>=0;i--){
            for (int j=1;j< arr.length;j++){
                ar[x][y]=arr[j][i];
                y++;
            }
            x++;
            y=0;
        }
        return ar;
    }
}

这是该方法的执行效率，可以看出除了代码的目视行数较低外效率并不高