顺时针打印矩阵

给定任意一个矩阵，要求顺时针打印完矩阵 如：
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

思路

首先要确定循环结束的条件：
起始位置为（0,0）
第二次起始位置为（1,1）
第三次为（2,2）
以此推类：第n次为（n，n） 如4,4矩阵 第二次为1,1 第三次为2,2 但是2,2不在起始位置不满足第三次开始条件。
4>1X2 4>1X2 如果为6,6矩阵 6>2X2 ，满足起始位置的2倍条件；
得出 如果起始位置的row和column 的2倍小于矩阵的row和column。则可以第n次循环；

代码

    //判断是否打印
    public static void printMatrixClockwisely(int[][] matrix, int rows, int columns){
        if (matrix == null || rows ==0 || columns == 0) {
            return;
        }
        //定义起始位置
        int start = 0;
        //找到左上角位置（位置每次都为 0,0 1，1 2,2 之类 rows与columns相同）
        //左上角位置的row*2和column*2如果小于矩阵的rows和columns证明还可以打印
        while (rows > start * 2 && columns > start * 2) {
            //打印当前的start的row和column
            PrintMatrixInCircle(matrix, start, rows, columns);
            start++;
        }
    }

打印思路

依次打印左到右，上到下，右到左，下到上。需要判断条件最后位置是否大于（小于）开始位置

代码

private static void PrintMatrixInCircle(int[][] matrix, int start, int rows, int columns) {
    int endRow = rows - 1 - start;
    int endColumn = columns - 1 - start;

    //从左到右打印行
    for (int i = start; i < endColumn; i++) {
        int print = matrix[start][i];
        System.out.println(print);
    }

    //从上到下打印列
    if (start < endRow) {
        for (int i = start + 1; i <= endRow; i++) {
            int print = matrix[i][endColumn];
            System.out.println(print);
        }
    }

    //从右到做打印行
    if (endColumn > start && endColum > start) {
        for (int i = endColumn - 1; i >= start; i--) {
            int print = matrix[endRow][i];
            System.out.println(print);
        }
    }

    //从下到上打印列
    if (endColumn > start && endRow > start + 1) {
        for (int i = endRow - 1; i > start; i--) {
            int print = matrix[i][start];
            System.out.println(print);
        }
    }
}

测试用例

public static void main(String[] args) {
    int[][] matrix = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
    printMatrixClockwisely(matrix, 4, 4);
}

结果

practice.PrintMatrixClockwisely
1
2
3
4
8
12
16
15
14
13
9
5
6
7
11
10

Process finished with exit code 0

整体代码

package practice;


/**
 * @author iu
 * 顺时针打印矩阵
 * rows为行，columns为列
 */
public class PrintMatrixClockwisely {
    //判断是否打印
    public static void printMatrixClockwisely(int[][] matrix, int rows, int columns){
        if (matrix == null || rows ==0 || columns == 0) {
            return;
        }
        //定义起始位置
        int start = 0;
        //找到左上角位置（位置每次都为 0,0 1，1 2,2 之类 rows与columns相同）
        //左上角位置的row*2和column*2如果小于矩阵的rows和columns证明还可以打印
        while (rows > start * 2 && columns > start * 2) {
            //打印当前的start的row和column
            PrintMatrixInCircle(matrix, start, rows, columns);
            start++;
        }
    }

    private static void PrintMatrixInCircle(int[][] matrix, int start, int rows, int columns) {
        int endRow = rows - 1 - start;
        int endColumn = columns - 1 - start;

        //从左到右打印行
        for (int i = start; i <= endColumn; i++) {
            int print = matrix[start][i];
            System.out.println(print);
        }

        //从上到下打印列
        if (start < endRow) {
            for (int i = start + 1; i <= endRow; i++) {
                int print = matrix[i][endColumn];
                System.out.println(print);
            }
        }

        //从右到做打印行
        if (endColumn > start && endRow > start) {
            for (int i = endColumn - 1; i >= start; i--) {
                int print = matrix[endRow][i];
                System.out.println(print);
            }
        }

        //从下到上打印列
        if (endColumn > start && endRow > start + 1) {
            for (int i = endRow - 1; i > start; i--) {
                int print = matrix[i][start];
                System.out.println(print);
            }
        }
    }

    public static void main(String[] args) {
        int[][] matrix = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
        printMatrixClockwisely(matrix, 3, 4);
    }
}