数组和矩阵

转圈打印矩阵
[题目]
给定一个整型矩阵matrix，请按照转圈的方式打印它
例如：
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
[要求]
额外空间复杂度为O(1)
[思路]
如果你按照下标的方式控制什么时候换行就比较麻烦了，下面我们介绍一种矩阵的处理方式，该方式也是处理矩阵的一种思路，代码实现起来也比较简便。
矩阵分圈处理：
1:在矩阵中用左上角的坐标（tR,tC）和右下角的坐标(dR,dC)就可以表示一个子矩阵。
比如题目中的矩阵，当(tR,tC)=(0,0)和（dR,dC）=（3,3）表示的子矩阵是整个矩阵，这个矩阵的最外层为：
1 2 3 4
5 8
9 12
13 14 15 16
当(tR,tC)=(0,0)和（dR,dC）=（3,3）时候，打印的结果是1,2,3,4,8,12,16,15,14,13,9,5
2:接着我们改变tR,tC,dR,dC的值，让(tR,tC)=(1,1)和 （dR,dC）=（2,2）此时表示的子矩阵为：
6 7
10 11
在把这个矩阵打印出来：6,7,11,10
3：打印结束的条件是左上角的下标大于右下角的下标（左上角坐标跑到右下角坐标的右方或者下方）
[代码实现]

package 数组和矩阵;

public class Main1 {

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

    /**转圈打印*/
    private static void zhuanQuanPrint(int[][] matrix) {
        
        //定义左上角的坐标
        int tR = 0;
        int tC = 0;
        //定义右下角的坐标
        int dR=matrix.length-1;
        int dC=matrix[0].length-1;
        
        /**转圈打印*/
        while (tR<=dR || tC<=dC) {
            printEdage(matrix,tR++,tC++,dR--,dC--);
        }
        
    }

    /**转圈打印最外层*/
    private static void printEdage(int[][] matrix, int tR, int tC, int dR,
            int dC) {
        
        /**子矩阵只有一行*/
        if (tR == dR) {
            for (int i=tC;i<=dC;i++) {
                System.out.print(matrix[tR][i]+" ");
            }
        } else if(tC==dC){/**子矩阵只有一列*/
            for (int i=tR;i<=dR;i++) {
                System.out.print(matrix[i][tC]);
            }
        } else {//普通情况
            int curC = tC;
            int curR = tR;
            while (curC != dC) {
                System.out.print(matrix[tR][curC]+" ");
                curC++;
            }
            
            while (curR != dR) {
                System.out.print(matrix[curR][dC]+" ");
                curR++;
            }
            
            while (curC != tC) {
                System.out.print(matrix[dR][curC]+" ");
                curC--;
            }
            
            while (curR != tR) {
                System.out.print(matrix[curR][tC]+" ");
                curR--;
            }
            
        }
        
    }
    
}

2.将正方形矩阵顺时针转动90度
[题目]
给定一个NN的矩阵matrix，把这个矩阵调整成顺时针转动90度后的形式.
例如：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
顺时针转动90度后为：
13 9 5 1
14 10 6 2
15 11 7 3
16 12 8 4
[要求]
额外空间复杂度为O(1)
[思路]
分圈处理方式：在矩阵中左上角和右下角就可以表示一个子矩阵,当（tR,tC）=(0,0)和（dR,dC）=(3,3)表示的矩阵是
1 2 3 4
5 8
9 12
13 14 15 16
在这个矩阵中1,4,16,13为一组，然后1占据4的位置，4占据16的位置，16占据13的位置，13占据1的位置，一组就调整完，然后2,8,15,9为一组继续上述的调整，最后3,12,14,5为一组，当矩阵为44的时候分成了3租就调整结束，如果子矩阵的大小是M*M，一共就有M-1组，分别进行占据调整就可以了。

[代码实现]

package 数组和矩阵;

public class Main2 {

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

    private static void print(int[][] matrix) {
        for (int i=0;i<matrix.length;i++) {
            for (int j=0;j<matrix[0].length;j++) {
                System.out.print(matrix[i][j]+" ");
            }
            System.out.println();
        }
        
    }

    /**矩阵顺时针旋转*/
    private static void rotatePrint(int[][] matrix) {
        
        /**左上角坐标*/
        int tC=0;
        int tR=0;
        /**右下角坐标*/
        int dC=matrix.length-1;
        int dR = matrix[0].length-1;
        
        /**旋转打印*/
        while (tR < dR) {
            rotateEdge(matrix,tC++,tR++,dC--,dR--);
        }
        
    }

    /**顺时针旋转*/
    private static void rotateEdge(int[][] matrix, int tC, int tR, int dC, int dR) {
        
        int times = dC-tC;//总的次数
        int temp=0;
        for (int i=0;i!=times;i++) {/**一次循环就是一次调整*/
            temp = matrix[tR][tC+i];//第一次1的位置为空，13填进去
            matrix[tR][tC+i] = matrix[dR-i][tC];//13为空
            matrix[dR-i][tC] = matrix[dR][dC-i];//16填13位置
            matrix[dR][dC-i] = matrix[tR+i][dC];//16为空4填
            matrix[tR+i][dC] = temp;
            
        }
        
    }
    
}