剑指offer——顺时针打印矩阵

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.

2. 解决方法

2.1 level1

这也是一道非常经典的题目，记得曾经是使用C语言写的，最简单的方法就是按照题目要求这样打印出来，从左到右，从上到下，从右到左，从下到上，分4个循环，再依靠上下左右边界即可完成：

public static ArrayList<Integer> printMatrix(int [][] matrix) {
ArrayList<Integer> al = new ArrayList<>();
int row = matrix.length;
if (row == 0)
return al;
int col = matrix[0].length;
// 短的边/2，向上取整
int circle = ((row > col ? col : row) + 1) / 2;
for (int i = 0; i < circle; i++) {

// 从左向右打印，j=i; j<col-i,
// 这一行的前i个已经在第i圈从下往上被打印，故j=i
// 倒数i个都已经在第i圈从上往下被打印，故j=col-i-1<col-i
for (int j = i; j < col - i; j++)
al.add(matrix[i][j]);

// 从上往下打印，j=i+1;j<row-i,
// 这一列的前i+1个已经在从左向右打印时被打印,故j=i+1
// 倒数i个已经在第i圈从右往左被打印,故j=row-i-1<row-i
for (int j = i + 1; j < row - i; j++)
al.add(matrix[j][col - i - 1]);

// 从右往左打印，j=col-i-2;j>=i&&row-i-1!=i;，
// 这一行倒数i个已经在第i圈从上往下被打印
// 这一行倒数第i+1个已经在从上往下时被打印，故j=col-1-(i+1)=col-i-2
// 这一行的前i个已经在从下往上时被打印，故j=i>=i
// 当第i圈为0时即从未由上往下打印时，col有多列时，会造成重复打印，故判断row-i-1!=i以避免
for (int j = col - i - 2; j >= i && row - i - 1 != i; j--)
al.add(matrix[row - i - 1][j]);

// 从下往上打印，j=row-i-2;j>i&&col-i-1!=i，
// 这一列倒数i个已经在第i圈从右往作被打印
// 这一列倒数第i+1个已经在从右往左时被打印，故j=row-1-(i+1)=row-i-2
// 这一列的前i个已经在第i圈从左往右时被打印，
// 这一列的第i+1个已经在本圈从左往右被打印，故j=i+1>i
// 当第i圈为0时即从未由右向左打印时，row有多行时，会造成重复打印，故判断col-i-1!=i以避免
for (int j = row - i - 2; j > i && col - i - 1 != i; j--)
al.add(matrix[j][i]);
}
return al;
}

2.2 level2

但是事实上，如果使用旋转魔方的方法，会减轻不少工作量，每次只取一行，然后逆时针旋转矩阵并去掉已经读取过的那一行，然后依次循环知道无矩阵可旋转：

public static ArrayList<Integer> printMatrix(int[][] matrix) {
ArrayList<Integer> al = new ArrayList<>();
int row = matrix.length;
while (row != 0) {
for (int i = 0; i < matrix[0].length; i++) {
al.add(matrix[0][i]);
}
if (row == 1)
break;
matrix = turn(matrix);
row = matrix.length;
}
return al;
}

private static int[][] turn(int[][] matrix) {
// TODO 自动生成的方法存根
int col = matrix[0].length;
int row = matrix.length;
int[][] newMatrix = new int[col][row - 1];
for (int j = col - 1; j >= 0; j--) {
for (int i = 1; i < row; i++) {
newMatrix[col - 1 - j][i - 1] = matrix[i][j];
}
}
return newMatrix;
}

2.3 level3

上述方法尽管巧妙，但是还不够生动，如果把它看作是一个贪吃蛇的游戏的话，那么整个步骤就是分为2步，第一步吃掉当前所在地的数字，第二步探索有没有碰到墙，如果碰到墙，先记录该面墙的位置，然后把墙拉近一步，再向右转九十度走一步，不然的话就按原方向走一步。

public static ArrayList<Integer> printMatrix(int [][] matrix) {
ArrayList<Integer> result=new ArrayList<Integer>();
if(matrix==null||matrix.length==0){
return result;
}
int left=-1;
int right=matrix[0].length;
int top=0;
int buttom=matrix.length;
int maxcount=right*buttom;
int x=0,y=0;
//flag决定方向，0向右行，1向下行，2向左行，3向上行。
int flag=0;
while(result.size()<maxcount){
//先把当前的加入
result.add(matrix[x][y]);
//判断是否到头
switch(flag){
case 0:{
//如果是碰到墙了，改方向行走。
if(y==right-1){
flag=(flag+1)%4;
right--;
x++;
}
//不然往前走一步。
else{
y++;
}
break;
}
case 1:{
if(x==buttom-1){
flag=(flag+1)%4;
buttom--;
y--;
}
else{
x++;
}
break;
}
case 2:{
if(y==left+1){
flag=(flag+1)%4;
left++;
x--;
}
else{
y--;
}
break;
}
case 3:{
if(x==top+1){
flag=(flag+1)%4;
top++;
y++;
}
else{
x--;
}
break;
}
}
}
return result;
}

毕竟这样似乎看起来会生动一些，有点人工智能的味道在里面。

3. 小结

通过上面的例子我们可以看到，把抽象枯燥的问题，完全可以化解为一个非常有趣的模型，然后再继续建模的话，会好很多。