剑指offer：顺时针打印矩阵

题目描述

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

 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. 
题目传送

 

解题思路

方法一：使用辅助数组

1. 新建一个一样大的二维矩阵初始化为0，代表所有元素未访问。
2. 设置循环的结束条件即某一圈开始的左上点是否大于整个二维矩阵的中心点。
3. 每一圈安装顺序打印矩阵，打印前判断该点是否访问过，避免重复打印，打印后将该点设置为1，代表已经访问。

import java.util.ArrayList; 
public class Solution { 
    ArrayList<Integer> ret = new ArrayList<Integer>(); 
    public ArrayList<Integer> printMatrix(int [][] matrix) { 
        if(matrix==null) 
            return null; 
        int rows = matrix.length; 
        int cols = matrix[0].length; 
        // 定义是否访问二维数组，判断该点是否已经输出 
        int [][] hasAcess = new int[rows][cols]; 
        // 初始化二维数组，0代表该点未输出，1代表该点以输出 
        for(int i=0; i < hasAcess.length; ++i) 
          for(int j=0; j<hasAcess[i].length; ++j) 
             hasAcess[i][j] = 0; 
        // 循环的结束条件，简洁！ 
        int start = 0; 
        while (cols>start*2 && rows>start*2){ 
            PrintMatrixInCicle(matrix, cols, rows, start, hasAcess); 
            start++; 
        } 
        return ret; 
    } 
    public void PrintMatrixInCicle(int [][] matrix, int cols, int rows, int start, int [][] hasAcess){ 
        // 四个方向打印数组，如果该点没有访问则输出，访问过则跳过 
        int endRow = rows-1-start; 
        int endcol = cols-1-start; 
        // 从左到右 
        for(int i=start; i<cols; i++){ 
            if(hasAcess[start][i] == 0){ 
                ret.add(matrix[start][i]); 
                hasAcess[start][i] = 1; 
            } 
        } 
        // 从上到下 
        for(int i=start+1; i<rows; i++){ 
            if(hasAcess[i][endcol] == 0){ 
                ret.add(matrix[i][endcol]); 
                hasAcess[i][endcol] = 1; 
            } 
        } 
        // 从右到左 
        for(int i=endcol-1; i>=start; i--){ 
            if(hasAcess[endRow][i] == 0){ 
                ret.add(matrix[endRow][i]); 
                hasAcess[endRow][i] = 1; 
            } 
        } 
        // 从下到上 
        for(int i=endRow-1; i>=start; i--){ 
            if(hasAcess[i][start] == 0){ 
                ret.add(matrix[i][start]); 
                hasAcess[i][start] = 1; 
            } 
        } 
    } 
} 

  
方法二：不使用辅助数组

用左上和右下的坐标定位出一次要旋转打印的数据，一次旋转打印结束后，往对角分别前进和后退一个单位。

易错点在于没有控制好后两个for循环，需要加入条件判断，防止出现单行或者单列的情况。

import java.util.ArrayList; 
public class Solution { 
    public ArrayList<Integer> printMatrix(int [][] matrix) { 
        int row = matrix.length; 
        int col = matrix[0].length; 
        if (row == 0 || col == 0)  return null; 
        ArrayList<Integer> list = new ArrayList<Integer>(); 
        int left = 0,top = 0,bottom = row - 1,right = col - 1; 
        while(left <= right && top <= bottom){ 
            for(int i = left;i<=right;i++){ 
                list.add(matrix[top][i]); 
            } 
            for(int j = top+1;j<=bottom;j++){ 
                list.add(matrix[j][right]); 
            } 
            if (top != bottom) 
                for(int t = right-1;t>=left;t--){ 
                    list.add(matrix[bottom][t]); 
                } 
            if(left != right) 
                for(int k = bottom-1;k>top;k--){ 
                    list.add(matrix[k][left]); 
                } 
            top++;left++;right--;bottom--; 
        } 
        return list; 
    } 
}