《剑指offer》顺时针输出矩阵问题的解决方案

因为这题卡了很久，所以要分享一下
大概思路是一个矩阵可以分为若干方框，进行输出，如下：
1   2   3   4                    1   2   3   4   
5   6   7   8                    5           8     6  7
9  10  11  12    这个矩阵可以分成    9         12    10 11
13 14  15  16                    13           16     14 15
17 18  19  20                    17           20     18 19
21 22  23  24                    21 22  23  24
两个方框来输出，每个方框分成四轮进行输出，如第一个框，分别输出：
1，2，3
4，8，12，16，20
24,23,22
21,17,13,9,5
可以发现，从matrix[0][0]开始输出，顶部行先输出3个，右边列输出5个，然后底部行在输出3个，左边列再输出5个
当一个方框全部输出完毕之后，进行内部小方框的初始化
内部的框框，从matrix[1][1]开始输出，顶部行先输出1个，右边列输出3个，底部行在输出1个，左边列再输出3个
由此将问题从具体转抽象，n*m的矩阵，第1个方框每行输出n-1，每列输出m-1，第2个方框每行输出n-3，每列输出m-3……以此类推
第k个小方框，从matrix[k-1][k-1]开始输出，每行输出n-2*k-1，每列输出m-2*k-1；
借助两个整型变量，x，y作为指针，借助一个整型变量count做为计数器，来判断应该如何改变x和y，以及是否需要初始化，具体代码如下

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        //因为这题卡了很久，所以要分享一下
        //大概思路是一个矩阵可以分为若干方框，进行输出，如下：
        //1   2   3   4                    1   2   3   4   
        //5   6   7   8                    5           8     6  7
        //9  10  11  12    这个矩阵可以分成    9         12    10 11
        //13 14  15  16                    13           16     14 15
           //17 18  19  20                    17           20     18 19
        //21 22  23  24                    21 22  23  24
        //两个方框来输出，每个方框分成四轮进行输出，如第一个框，分别输出：
        //1，2，3
        //4，8，12，16，20
        //24,23,22
        //21,17,13,9,5
        //可以发现，从matrix[0][0]开始输出，顶部行先输出3个，右边列输出5个，然后底部行在输出3个，左边列再输出5个
        //当一个方框全部输出完毕之后，进行内部小方框的初始化
        //内部的框框，从matrix[1][1]开始输出，顶部行先输出1个，右边列输出3个，底部行在输出1个，左边列再输出3个
        //由此将问题从具体转抽象，n*m的矩阵，第1个方框每行输出n-1，每列输出m-1，第2个方框每行输出n-3，每列输出m-3……以此类推
        //第k个小方框，从matrix[k-1][k-1]开始输出，每行输出n-2*k-1，每列输出m-2*k-1；
        //借助两个整型变量，x，y作为指针，借助一个整型变量count做为计数器，来判断应该如何改变x和y，以及是否需要初始化，具体代码如下
        if(matrix.length==0||matrix==null){
            return null;
        }
        ArrayList<Integer> result = new ArrayList<>();

           
        int all = matrix.length * matrix[0].length;// 25
        int stepRow = matrix.length - 1;// 4
        int stepCol = matrix[0].length - 1;// 4
        int count = 0;
        int i = 0;
        int j = 0;
        while (result.size() < all) {
            result.add(matrix[i][j]);
            if (count < stepCol) {
                j++;
            } else if (count < stepCol + stepRow) {
                i++;
            } else if (count < stepCol * 2+stepRow) {
                j--;
            } else if (count < stepCol * 2+stepRow*2) {
                i--;
            }
            if (count == stepRow * 2+stepCol*2 - 1) {
                count = 0;
                stepRow -= 2;
                stepCol -= 2;
                i++;
                j++;
            }else{
                count++;                
            }
        }

        return result;
    }
}