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

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

import java.util.Arrays;

class Solution_29 {
    public int[] spiralOrder(int[][] matrix) {
        if(matrix.length != 0){     //当输入数组不为空时
            int[]  arr = new int[matrix.length * matrix[0].length]; //matrix.length * matrix.length表示一维数组长度

            //遍历的初始位置
            int startX = 0;
            int startY = 0;

            //一维数组的起始位置
            int start_1 = 0;

            //偏移量
            int offset = 1;

            if(matrix.length > 1 && matrix[0].length > 1){  //当数组行和列都大于1时

                //循环次数，仅当行和列都满足时才可以循环
                int times_X = matrix.length / 2;
                int times_Y = matrix[0].length / 2;

                while(times_X > 0  && times_Y > 0){

                    int i = startX;
                    int j = startY;

                    //上侧，从左到右 前闭后开原则[)
                    for(; j < matrix[startY].length - startY - offset; j++){
                        arr[start_1] = matrix[i][j];
                        start_1++;
                    }

                    //右侧，从上到下 前闭后开原则[)
                    for(; i < matrix.length - startX - offset; i++){
                        arr[start_1] = matrix[i][j];
                        start_1++;
                    }


                    //下侧，从右到左 前闭后开原则[)
                    for(; j > startY; j--){
                        arr[start_1] = matrix[i][j];
                        start_1++;
                    }

                    //左侧，从下到上 前闭后开原则[)
                    for(; i > startX; i--){
                        arr[start_1] = matrix[i][j];
                        start_1++;
                    }

                    if(times_X >= 1 || times_Y>=1){     //循环条件
                        times_X--;
                        times_Y--;
                        startX++;
                        startY++;
                    }
                }

                if(startX == matrix.length-1 || startY == matrix[0].length-1){  //当初始位置在数组边缘时，表示遍历完成
                    return arr;
                }

                while(times_X >  times_Y){  //当行数还可以循环，而列数不可以时（及存在某一列还有剩余元素）
                    int x = matrix.length - matrix[0].length + 1;
                    for(int k = 0; k < x; k++){
                        arr[start_1] = matrix[k+startX][startY];
                        start_1++;
                    }
                    return arr;
                }

                while(times_X < times_Y){  //当列数还可以循环，而行数不可以时（及存在某一行还有剩余元素）
                    int x = matrix[0].length - matrix.length + 1;
                    for(int y = 0; y < x; y++){
                        arr[start_1] = matrix[startX][y+startY];
                        start_1++;
                    }
                    return arr;
                }

                while(matrix.length == matrix[0].length && matrix.length % 2 ==1 ){  //输入为正方形矩阵时
                    arr[start_1] = matrix[startX][startY];
                    return arr;
                }

            }else if(matrix.length == 1){       //只有一行时
                for(int i = 0; i < matrix[0].length; i++){
                    arr[start_1++] = matrix[0][i];
                }
            }else if(matrix[0].length == 1){    //只有一列时
                for(int i = 0; i < matrix.length; i++){
                    arr[start_1++] = matrix[i][0];
                }
            }
            return arr;
        }

        //当输入数组为空时
        int[]arr = {};
        return arr;
    }
}

public class offer_29 {
    public static void main(String[] args){
        
        //创建二维数组的方式
        int[][] arr = new int[3][3];    //方式一
        int[][] arr1 = {{2,3,4},{5,6,7},{8,9,10},{11,12,13},{14,15,16}};   //方式二

        int[][] arr2 = {{2,5},{8,4},{0,-1}};
        int[][] arr3= {{1,2,3,4,5,6,7,8,9,10},{11,12,13,14,15,16,17,18,19,20}};

//        System.out.println(arr1.length);    //二维数组的行数
//        System.out.println(arr1[0].length); //二维数组的0行的数量

        Solution_29 sol = new Solution_29();
        int[] ans = sol.spiralOrder(arr1);
        System.out.println(Arrays.toString(ans));
    }
}