顺时针打印矩阵

一，问题描述

给定一个N x N 的矩阵（方阵），按照从外向里的以顺时针方向依次打印矩阵中的每个元素。

比如：一个 3X3的矩阵如下：打印顺序为：1 2 3 6 9 8 7 4

{1,2,3}
{4,5,6}
{7,8,9}

打印方向如下：

二，算法思路

可以采用递归的方式来打印整个矩阵中的元素。

首先按顺时针方向打印最外层的元素，然后再递归地打印更里层的元素。

对于N维方阵而言：每打印一圈之后，维数降低2。当N为奇数时，最终递归到 1x1矩阵。当N为偶数时，最终递归到N=0

因此，递归的基准条件：当N==0 时，直接返回。 N==1时，打印矩阵中唯一的那个元素，然后返回。

具体代码如下：

    private static void printArray(int[][] arr, int row, int column, int n){
        //base condition
        if(n == 0)
            return;
        if(n == 1){
            print(arr[row][column]);
            return;
        }
        
        printElementClockWise(arr, row, column);//clockwise print element
        printArray(arr, row + 1, column - 1, n - 2);//recursively call
    }

①第3行和第5行的if表示的是递归的基准条件

②第10行，是顺时针打印矩阵中的元素。注意：它在递归调用之前执行，这说明：打印顺序是从外到内的。(对递归的理解)说白了，就是先打印了外层的元素，再递归调用打印内层元素。

③第10行执行递归调用。因为打印的是更里层的元素，故待打印的元素的位置：行数增加1，列数减少1

每打印一圈之后，数组的维数降低2

三，完整代码实现

public class PrintArray {
    
    public static void printArray(int[][] arr){
        if(arr == null || arr.length == 0)
            return;
        printArray(arr, 0, arr.length - 1, arr.length);
    }
    
    private static void printArray(int[][] arr, int row, int column, int n){
        //base condition
        if(n == 0)
            return;
        if(n == 1){
            print(arr[row][column]);
            return;
        }
        
        printElementClockWise(arr, row, column);//clockwise print element
        printArray(arr, row + 1, column - 1, n - 2);//recursively call
    }
    
    /**
     * 顺时针由外到内打印数组
     * @param arr
     * @param row
     * @param column
     */
    private static void printElementClockWise(int[][] arr, int row, int column){
        for(int i = row; i <= column; i++)
            print(arr[row][i]);
        for(int i = row + 1; i <= column; i++)
            print(arr[i][column]);
        for(int i = column - 1; i >= row; i--)
            print(arr[column][i]);
        for(int i = column - 1; i > row; i--)
            print(arr[i][row]);
    }
    
    private static void print(int i){
        System.out.print(i + " ");
    }
    
    //for test purpose
    public static void main(String[] args) {
        int[][] arr = {
                {1,2,3},
                {4,5,6},
                {7,8,9}
        };
        System.out.println("arr.length:" + arr.length);
        printArray(arr);
        System.out.println();
        int[][] arr2 = {
                {1,2,3,10},
                {4,5,6,11},
                {7,8,9,12},
                {13,14,15,16}
        };
        printArray(arr2);
        
        int[][] arr3 = {};
        System.out.println(arr3.length);
        printArray(arr3);
        printArray(null);
    }
}

扩展：根据上面的思路，我们也可以构造一个蛇形矩阵。

    private void print(int[][] arr, int row, int col){
        for(int i = row; i <= col; i++)
            arr[row][i] = count++;
//            System.out.print(arr[row][i]);
        for(int i = row+1; i <= col; i++)
            arr[i][col] = count++;
//            System.out.print(arr[i][col]);
        for(int i = col-1; i >= row; i--)
            arr[col][i] = count++;
//            System.out.print(arr[col][i]);
        for(int i = col-1; i > row; i--)
            arr[i][row] = count++;
//        System.out.print(arr[i][row]);
    }

count是个静态全局变量，初始值为1