算法篇6：数组与矩阵的操作（正方矩阵旋转，之字形打印）

旋转正方形矩阵

【题目】

给定一个整型正方形矩阵matrix，请把该矩阵调整成 顺时针旋转90度的样子。 【要求】 额外空间复杂度为O(1)。

解题思路：

从宏观角度来看，我们只需将最外圈转对，里面一样转即可，外围圈只需找到对应点，然后交换位置，那我们只需确定这四个对应点即可。

 1  2  3  4  

5  6  7  8 

9  10  11  12

13  14  15  16

则对应1，4，16，13一组，··········                                                                                                               

代码实现：

 

package com.xqc.sort;

public class RotateMatrix {

    public static void rotate(int[][] matrix) {
        int tR = 0;
        int tC = 0;
        int dR = matrix.length - 1;
        int dC = matrix[0].length - 1;
        while (tR < dR) {
            rotateEdge(matrix, tR++, tC++, dR--, dC--);
        }
    }

    public static void rotateEdge(int[][] m, int tR, int tC, int dR, int dC) {
        int times = dC - tC; 
        int tmp = 0;
        for (int i = 0; i != times; i++) {
            
            //寻找每圈对应的点
            tmp = m[tR][tC + i];
            m[tR][tC + i] = m[dR - i][tC];
            m[dR - i][tC] = m[dR][dC - i];
            m[dR][dC - i] = m[tR + i][dC];
            m[tR + i][dC] = tmp;
        }
    }

    public static void printMatrix(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();
        }
    }

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

    }

}

 

之字型打印：

【题目】

给定一个矩阵matrix，按照“之”字形的方式打印这 个矩阵，例如： 1 2 3 4 5 6 7 8 9 10 11 12 “之”字形打印的结果为：1，2，5，9，6，3，4，7，10，11， 8，12 【要求】 额外空间复杂度为O(1)。

解题思路：

我们只需要定义两个指针A 和指针B，让A先往右走，走到头再往下，B先往下走，走到头再往右，这样A和B所连成的线即位打印所需对角线，我们只需判断应该从上往下，还是重下往上打印即可。

代码实现：

package com.xqc.sort;

public class ZigZagPrintMatrix {

    public static void printMatrixZigZag(int[][] matrix) {
        //指针A的行数与列数
        int aR = 0;
        int aC = 0;
        //指针B的行数与列数
        int bR = 0;
        int bC = 0;
        //行数与列数的最大值
        int endR = matrix.length - 1;
        int endC = matrix[0].length - 1;
        
        boolean fromUp = false;
        while (aR != endR + 1) {
            
            printLevel(matrix, aR, aC, bR, bC, fromUp);
            //判断指针A与指针B怎么走
            aR = aC == endC ? aR + 1 : aR;
            aC = aC == endC ? aC : aC + 1;
            bC = bR == endR ? bC + 1 : bC;
            bR = bR == endR ? bR : bR + 1;
            fromUp = !fromUp;
        }
        
        System.out.println();
    }

    public static void printLevel(int[][] m, int tR, int tC, int dR, int dC,
            boolean f) {
        if (f) {
            while (tR != dR + 1) {
                System.out.print(m[tR++][tC--] + " ");
            }
        } else {
            while (dR != tR - 1) {
                System.out.print(m[dR--][dC++] + " ");
            }
        }
    }

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

    }

}