剑指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. 小结

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