剑指offer（第二版）——顺时针打印矩阵

PS：《剑指offer》是很多同学找工作都会参考的一本面试指南，同时也是一本算法指南（为什么它这么受欢迎，主要应该是其提供了一个循序渐进的优化解法，这点我觉得十分友好）。现在很多互联网的算法面试题基本上可以在这里找到影子，为了以后方便参考与回顾，现将书中例题用Java实现（第二版），欢迎各位同学一起交流进步。

GitHub： https://github.com/Uplpw/SwordOffer。

剑指offer完整题目链接： https://blog.csdn.net/qq_41866626/article/details/120415258

1 题目描述

输入一个矩阵，按照从外向里以顺时针的顺序一次打印出每一个数字。
如果输入如下矩阵：

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。

leetcode链接： 顺时针打印矩阵（以下代码已测试，提交通过）

2 测试用例

一般是考虑功能用例，特殊（边缘）用例或者是反例，无效测试用例这三种情况。甚至可以从测试用例寻找一些规律解决问题，同时也可以让我们的程序更加完整鲁棒。

（1）功能用例：正常的矩阵，多行多列的矩阵。

（2）边缘用例：一行或者一列的矩阵。

（3）无效用例：矩阵为空，或者没有元素。

3 思路

分析：

根据上面的例子可以看出，打印外圈和内圈是一样的逻辑，因此可以使用递归解决，注意边界问题即可。

4 代码

算法实现：

public class PrintMatrix {
    public static int[] spiralOrder(int[][] matrix) {
        if (matrix == null) {
            return new int[0];
        }
        if(matrix.length==0){
            return new int[0];
        }
        int length = matrix.length * matrix[0].length;
        int[] array = new int[length];
        spiralOrderCore(array, 0, matrix, 0, matrix.length - 1, 0, matrix[0].length - 1);
        return array;
    }

    public static void spiralOrderCore(int[] array, int index, int[][] matrix, int rowStart, int rowEnd,
                                       int colStart, int colEnd) {
        if (rowStart > rowEnd || colStart > colEnd) {
            return;
        }
        int count = index;
        // 只有一行
        if (rowStart == rowEnd) {
            for (int j = colStart; j <= colEnd; j++) {
                array[count++] = matrix[rowStart][j];
            }
            return;
        }
        // 只有一列
        if (colStart == colEnd) {
            for (int i = rowStart; i <= rowEnd; i++) {
                array[count++] = matrix[i][colStart];
            }
            return;
        }
        // 矩阵第一行
        for (int j = colStart; j <= colEnd; j++) {
            array[count++] = matrix[rowStart][j];
        }
        // 矩阵最右一列
        for (int i = rowStart + 1; i <= rowEnd; i++) {
            array[count++] = matrix[i][colEnd];
        }
        // 矩阵最后一行
        for (int j = colEnd - 1; j >= colStart; j--) {
            array[count++] = matrix[rowEnd][j];
        }
        // 矩阵最左一列
        for (int i = rowEnd - 1; i >= rowStart + 1; i--) {
            array[count++] = matrix[i][colStart];
        }

        spiralOrderCore(array, count, matrix, rowStart + 1, rowEnd - 1, colStart + 1, colEnd - 1);
    }

    public static void main(String[] args) {
        int[][] data1 = {
                {1, 2, 3, 4},
                {12, 13, 14, 5},
                {11, 16, 15, 6},
                {10, 9, 8, 7},
        };
        int[][] data2 = {
                {1, 2, 3, 4},
                {10, 11, 12, 5},
                {9, 8, 7, 6},
        };
        int[][] data3 = {
                {1, 2, 3},
                {10, 11, 4},
                {9, 12, 5},
                {8, 7, 6},
        };
        int[][] data4 = {
                {1, 2, 3},
                {8, 9, 4},
                {7, 6, 5},
        };

        int[] array = spiralOrder(data3);
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "\t");
        }
        System.out.println();
    }
}

参考
在解决本书例题时，参考了一些大佬的题解，比如leetcode上的官方、K神，以及其他的博客，在之后的每个例题详解后都会给出参考的思路或者代码链接，同学们都可以点进去看看！

本例题参考：

1. https://www.jianshu.com/p/1bf321eff014

本文如有什么不足或不对的地方，欢迎大家批评指正，最后希望能和大家一起交流进步、拿到心仪的 offer !!!