一、题目描述：
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

二、解题思路：

顺时针打印矩阵.png

根据图片和题目描述，我们可以想象一下，从外圈到内圈顺序打印，我们可以把矩阵打印想象成n个圈的打印。我们可以通过一个循环来打印矩阵。那么这个循环结束的条件是什么？假设这个矩阵的行数是rows，列数是columns，打印第一圈的左上角的坐标是（0，0）,打印第二圈的左上角的坐标是（1，1）,以此类推。我们可以得出左上角的坐标行号和列号是相同的。这里我们假设左上角的坐标是（start,start）。

对于mn的矩阵，最后一圈的左上角的坐标是（start,start）。条件是：m>start2&&n>start*2

打印一圈，至少需要一步（矩阵只有一行时），之多需要四步（矩阵至少有三行两列）

一步.png

打印一圈，只有一步时，即矩阵只有一行，此时从左到右打印。

两步.png

打印一圈，只有两步时，即矩阵至少有两行，并且终止行号比起始行号大，此时从上到下打印。

三步.png

打印一圈，只有三步时，即至少有两行两列，
终止行号比起始行号大，且终止列号比起始列号大，此时从右到左打印。

打印一圈，四步时，即至少有三行两列，终止行号比起始行号至少大2，且终止列号比起始列号大，此时从下到上打印。

三、代码实现：

import java.util.ArrayList;
import java.util.List;

/**
 * @author Aaron
 * @date 2018/10/24 下午2:40
 * @function 功能：顺时针打印矩阵
 */
public class PrintMatrixInCircle {
    public static ArrayList<Integer> printMatrix(int[][] matrix){
        ArrayList<Integer> list = new ArrayList<>();
        //行数
        int rows = matrix.length;
        //列数
        int cols = matrix[0].length;
        //边界条件排除
        if(matrix==null||cols<=0||rows<=0){
            return null;
        }

        int start = 0;
        //打印停止条件
        while(rows>start*2&&cols>start*2){
            printMatrixInCircle(list,matrix,cols,rows,start);
            ++start;
        }
        return list;
    }

    public static void printMatrixInCircle(ArrayList<Integer> list,int[][] nums,int cols,int rows,int start){

        int endX = cols - 1 - start;

        int endY = rows - 1 - start;

        //从左到右打印一行；打印条件：i<=endX
        for (int i=start;i <= endX;i++){
            int number = nums[start][i];
            list.add(number);
        }
        //从上到下打印一列；打印条件：终止行号大于起始行号
        if(start<endY){

            for (int i=start+1;i<=endY;i++){
                int number = nums[i][endX];
                list.add(number);
            }
        }
        //从右到左打印一行；打印条件：圈内至少有两行两列，就是要求终止行号大于起始行号和终止列号大于起始列号
        if(start<endX&&start<endY){
            for (int i = endX-1;i>=start;i--){
                int number = nums[endY][i];
                list.add(number);
            }
        }
        //从下到上打印一列；打印条件：圈内至少有三行两列，就是要终止行号比起始行号至少大2和终止列号大于起始列号
        if(start<endY-1&&start<endX){
            for(int i=endY-1;i>start;i--){
                int number = nums[i][start];
                list.add(number);
            }
        }
    }
    public static void printArray(List list){
        for (int i=0;i<list.size();i++){
            System.out.print(list.get(i)+",");
        }
    }

    public static void main(String[] args) {
        int[][] nums = new int[][]{{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
        List<Integer> list = printMatrix(nums);
        printArray(list);
    }
}

四、举一反三
改为：逆时针打印矩阵
思路和上面分析差不多。
代码实现：

import java.util.ArrayList;
import java.util.List;

/**
 * @author Aaron
 * @date 2018/10/24 下午2:40
 * @function 功能：逆时针打印矩阵
 */
public class PrintMatrixInCircle {
    public static ArrayList<Integer> printMatrix(int[][] matrix){
        ArrayList<Integer> list = new ArrayList<>();
        //行数
        int rows = matrix.length;
        //列数
        int cols = matrix[0].length;
        //边界条件排除
        if(matrix==null||cols<=0||rows<=0){
            return null;
        }

        int start = 0;
        //打印停止条件
        while(rows>start*2&&cols>start*2){
            //顺时针打印矩阵
//            printMatrixInCircle(list,matrix,cols,rows,start);
            //逆时针打印矩阵
            printMatrixInReverseCircle(list,matrix,cols,rows,start);
            ++start;
        }
        return list;
    }

    //（举一反三）逆时针打印矩阵
    public static void printMatrixInReverseCircle(ArrayList<Integer> list,int[][] nums,int cols,int rows,int start){
        int endX = cols - 1 - start;
        int endY = rows - 1 - start;

        //从右到左打印一行；打印条件：i>=0
        for(int i = endX;i>=start;i--){
            int number = nums[start][i];
            list.add(number);
        }
        
        //从上到下打印一列；打印条件：终止行号大于起始行号
        if(endY>start){
            for (int i = start+1;i<=endY;i++){
                int number = nums[i][start];
                list.add(number);
            }
        }
        
        //从左到右打印一行；打印条件：终止行号大于起始行号，且终止列号大于起始列号
        if(start<endX&&start<endY){
            for(int i = start+1;i<=endX;i++){
                int number = nums[endY][i];
                list.add(number);
            }
        }
        //从下到上打印一列；打印条件：至少三行两列；即终止行号大于起始行号2，且终止列号大于起始列号
        if(start<endY-1&&start<endX){
            for (int i=endY-1;i>start;i--){
                int number = nums[i][endX];
                list.add(number);
            }
        }
    }
    //顺时针打印矩阵
    public static void printMatrixInCircle(ArrayList<Integer> list,int[][] nums,int cols,int rows,int start){

        int endX = cols - 1 - start;

        int endY = rows - 1 - start;

        //从左到右打印一行；打印条件：i<=endX
       for (int i=start;i <= endX;i++){
            int number = nums[start][i];
            list.add(number);
        }
        //从上到下打印一列；打印条件：终止行号大于起始行号
        if(start<endY){

            for (int i=start+1;i<=endY;i++){
                int number = nums[i][endX];
                list.add(number);
            }
        }
        //从右到左打印一行；打印条件：圈内至少有两行两列，就是要求终止行号大于起始行号和终止列号大于起始列号
        if(start<endX&&start<endY){
            for (int i = endX-1;i>=start;i--){
                int number = nums[endY][i];
                list.add(number);
            }
        }
        //从下到上打印一列；打印条件：圈内至少有三行两列，就是要终止行号比起始行号至少大2和终止列号大于起始列号
        if(start<endY-1&&start<endX){
            for(int i=endY-1;i>start;i--){
                int number = nums[i][start];
                list.add(number);
            }
        }
    }
    public static void printArray(List list){
        for (int i=0;i<list.size();i++){
            System.out.print(list.get(i)+",");
        }
    }

    public static void main(String[] args) {
        int[][] nums = new int[][]{{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
        List<Integer> list = printMatrix(nums);
        printArray(list);
    }
}