（Java）顺时针打印矩阵

一、题目

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.

二、解题思路

通过观察可以发现，打印一圈一共分为四步，第一步从从左到右打印一行，第二步从上到下打印一列，第三步从右到左打印一行，第四步从下到上打印一列。每一步根据起始坐标和终止坐标用一个循环就可以打印出一行或者一列。

需要注意的是，最后一圈有可能退化成只有一行、一列、甚至只有一个数字，因此打印这样的一圈就不再需要四步。

因此需要仔细分析打印时每一步的前提条件，第一步肯定是需要的，因为打印一圈至少有一步。
如果只有一行，那就不需要第二步，也就是需要第二步的前提条件是终止行号大于起始行号。需要第三步打印的前提条件是圈内至少有两汉两列，即除了要求终止行号大于起始行号外，还要求终止列号大于起始列号
同理，需要打印第四步的前提条件是至少有三行两列，因此要求终止行号比起始行号至少大2，同时终止列号大于起始列号

这里的终止行号或者列号指的是相对的一圈的边界值

也就是每次我们都是判断四步，判断这四步哪些走，哪些没走，然后缩小圈，四步构成一个环

三、代码

这里需要注意的是，比如判断是否走第二步的条件是，这个环的高度至少是2，判断应该是

//rows-start_row-1表示当前行的下一行
rows - start_row - 1 > start_row;
不能写成 rows - start_row >=2;
不然这种情况对于内圈7,8，9就会出错：
1, 2, 3, 4, 5
6, 7, 8, 9, 10
11,12,13,14,15

package Interview;

import java.util.ArrayList;

class Solution {
    public ArrayList<Integer> printMatrix(int[][] matrix) {
        ArrayList<Integer> list = new ArrayList<>();
        if (matrix == null || matrix.length == 0) {
            return list;
        }
        //行数
        int row = matrix.length;
        //列数
        int col = matrix[0].length;
        //一圈起始行
        int start_row = 0;
        //一圈起始列
        int start_col = 0;
        while (start_row * 2 < row && start_col * 2 < col) {
            printMatrixClockwise(matrix, start_row, start_col, list);
            //走完一圈，行加一，列加一
            start_row++;
            start_col++;
        }
        return list;
    }

    private void printMatrixClockwise(int[][] matrix, int start_row, int start_col, ArrayList<Integer> list) {
        int rows = matrix.length;
        int cols = matrix[0].length;
        //1.执行第一步
        for (int i = start_col; i < cols - start_col; i++) {
            list.add(matrix[start_row][i]);
        }
        //2.环的高度至少为2才会执行第二步
        if (rows - start_row - 1 > start_row) {
            //由于右边那一列最上边的一个已经被输出了，所以从start_row +1 开始，同样输出包括右边最下面的那个
            for (int i = start_row + 1; i < rows - start_row; i++) {
                list.add(matrix[i][cols - start_col - 1]);
            }
        }
        //3.环的高度至少是2并且宽度至少是2才会执行第三步
        if (rows - start_row - 1 > start_row && cols - start_col - 1 > start_col) {
            //由于环的右下角的已经被输出了，所以列号从cols-start_col-2开始
            for (int i = cols - start_col - 2; i >= start_col; i--) {
                list.add(matrix[rows - start_row - 1][i]);
            }
        }
        //4.环的高度至少是3，宽度至少是2才会执行第四步
        if (rows - start_row - 1 > start_row + 1 && cols - start_col - 1 > start_col) {
            for (int i = rows - start_row - 1 - 1; i > start_row; i--) {
                list.add(matrix[i][start_col]);
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Solution s = new Solution();
        int[][] matrix = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12},
                {13, 14, 15, 16}
        };
        int[][] m = {
                {1, 2},
                {3, 4}
        };
        ArrayList<Integer> list = s.printMatrix(matrix);
        // ArrayList list = s.printMatrix(m);
        for (Integer each : list) {
            System.out.println(each);
        }
    }
}