顺时针打印矩阵

一，问题描述

给定一个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