矩阵旋转---上岸前的最后翻滚

1.序

记得在腾讯面试以及字节面试的时候有这么一道题----旋转矩阵。当时听到这个有点害怕，因为搜索过自己刷过的题没有这个，但是现在离大厂就差一道题，怎么办，逼着自己想。最后克服压力做出来了。后来把所有有关矩阵的整理了一遍，对之后的笔试面试都有很大的帮助，希望可以帮助大家梦想成真。

2.顺时针旋转90度

这道题腾讯面试题。重要的是空间复杂度为O（1）

public class Test24 {
    /*
     * 给定一个N*N的整形矩阵Matrix，把这个矩阵顺时针旋转90度，输入（打印）元素值。
     * 例如：
     *  1  2  3  4
     *  5  6  7  8
     *  9 10 11 12
     * 13 14 15 16
     * 输出结果为：
     * 	13 9  5 1
     *  14 10 6 2
     *  15 11 7 3
     *  16 12 8 4
     *
     * 要求：额外空间复杂度为O（1）
     * */
    public static void main(String[] args) {
//初始化一个 4*4的整形矩阵，从第一行第一列从左向右，第二行，第三行，直到第四行依次赋值 1,2,...16.
        int[][] matrixDemo=new int[4][4];
        matrixDemo=createMatrix();
        printMatrix(matrixDemo);
        System.out.println();
        //顺时针旋转90度打印
        rotate(matrixDemo);
        printMatrix(matrixDemo);
    }
    //顺时针旋转90度打印
    private static void rotate(int[][] matrix) {
        // TODO Auto-generated method stub
        int topRow=0;
        int topCol=0;
        int dowmRow = matrix.length-1;
        int dowmCol = matrix[0].length-1;
        while(topRow <= dowmRow) {
            rotateEdge(matrix, topRow++, topCol++, dowmRow--,dowmCol--);
        }
    }
    //顺时针旋转90度打印
    private static void rotateEdge(int[][] matrix, int topRow, int topCol, int dowmRow, int dowmCol) {
        // TODO Auto-generated method stub
        int times=dowmRow-topRow;
        // timies就是总的组数
        int temp=0;
        for(int i=0; i!=times;i++) {
            //一次循环就是一组调整
            temp=matrix[topRow][topCol+i];
            //赋值给临时变量 1  2
            matrix[topRow][topCol+i]=matrix[dowmRow-i][topCol];
            //7 --> 1  4 --> 2
            matrix[dowmRow-i][topCol]=matrix[dowmRow][dowmCol-i];
            //9 --> 7  8 --> 4 
            matrix[dowmRow][dowmCol-i]=matrix[topRow+i][dowmCol];
            //3 --> 9  6 --> 8
            matrix[topRow+i][dowmCol]=temp;
            //1 --> 3  2 --> 6
        }
    }
    //生成矩阵
    private static int[][] createMatrix() {
        // TODO Auto-generated method stub
        int matrix[][]=new int[4][4];
        int k=1;
        for(int i=0;i<4;i++) {
            for(int j=0;j<4;j++) {
                matrix[i][j]=k;
                k++;
            }
        }
        return matrix;
    }
    //顺序打印矩阵元素
    private static void printMatrix(int[][] matrix) {
        for(int i=0;i<4;i++) {
            for(int j=0;j<4;j++) {
                System.out.print(matrix[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

3.顺时针、逆时针、翻转

public class Test8 {
    public static void main(String[] args) {
        System.out.println("原");
        printMatrix(createMatrix());
        System.out.println("顺");
        printMatrix(change(createMatrix()));
        System.out.println("逆");
        printMatrix(helper(createMatrix()));
        System.out.println("翻转");
        printMatrix(fanzhuan(createMatrix()));
    }
    //生成矩阵
    private static int[][] createMatrix() {
        // TODO Auto-generated method stub
        int matrix[][]=new int[4][4];
        int k=1;
        for(int i=0;i<4;i++) {
            for(int j=0;j<4;j++) {
                matrix[i][j]=k;
                k++;
            }
        }
        return matrix;
    }
    //顺序打印矩阵元素
    private static void printMatrix(int[][] matrix) {
        for(int i=0;i<4;i++) {
            for(int j=0;j<4;j++) {
                System.out.print(matrix[i][j]+"\t");
            }
            System.out.println();
        }
    }

    //顺时针
    public static int[][] change(int [][]matrix){
        int [][]temp=new int[matrix[0].length][matrix.length];
        int dst=matrix.length-1;
        for(int i=0;i<matrix.length;i++,dst--){
            for(int j=0;j<matrix[0].length;j++){
                temp[j][dst]=matrix[i][j];
            }
        }
        return temp;
    }

    //逆时针
    public static int[][] helper(int[][] m_TestData){
        int iX, iY;
        int tmpData;
        int m_iHeight = m_TestData.length;
        int m_iWidth = m_TestData[0].length;

        for(iY=0; iY<m_iHeight; ++iY){
            iX= iY;
            for(; iX<m_iWidth; ++iX){
                tmpData = m_TestData[iY][iX];
                m_TestData[iY][iX] = m_TestData[iX][iY];
                m_TestData[iX][iY] = tmpData;
            }
        }

        for(iY=0; iY<m_iHeight/2; ++iY){
            for(iX=0; iX<m_iWidth; ++iX){
                tmpData = m_TestData[iY][iX];
                m_TestData[iY][iX] = m_TestData[m_iHeight-iY-1][iX];
                m_TestData[m_iHeight-iY-1][iX] = tmpData;
            }
        }
        return m_TestData;
    }
    public static int[][] fanzhuan(int[][] m_TestData) {
        int iX, iY;
        int tmpData;
        int m_iHeight = m_TestData.length;
        int m_iWidth = m_TestData[0].length;
        for (iY = 0; iY < m_iHeight / 2; ++iY) {
            for (iX = 0; iX < m_iWidth; ++iX) {
                tmpData = m_TestData[iY][iX];
                m_TestData[iY][iX] = m_TestData[m_iHeight - iY - 1][iX];
                m_TestData[m_iHeight - iY - 1][iX] = tmpData;
            }
        }
        return m_TestData;
    }
}

4.转置矩阵

给定一个矩阵 A， 返回 A 的转置矩阵。
矩阵的转置是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。
示例 1：
输入：[[1,2,3],[4,5,6],[7,8,9]]
输出：[[1,4,7],[2,5,8],[3,6,9]]
示例 2：
输入：[[1,2,3],[4,5,6]]
输出：[[1,4],[2,5],[3,6]]

public class Test9 {
    public static void main(String[] args) {
        printMatrix(createMatrix());
        printMatrix(transpose(createMatrix()));
    }
    //生成矩阵
    private static int[][] createMatrix() {
        // TODO Auto-generated method stub
        int matrix[][]=new int[4][4];
        int k=1;
        for(int i=0;i<4;i++) {
            for(int j=0;j<4;j++) {
                matrix[i][j]=k;
                k++;
            }
        }
        return matrix;
    }
    //顺序打印矩阵元素
    private static void printMatrix(int[][] matrix) {
        for(int i=0;i<4;i++) {
            for(int j=0;j<4;j++) {
                System.out.print(matrix[i][j]+"\t");
            }
            System.out.println();
        }
    }
    public static int[][] transpose(int[][] A) {
        int row=A.length;
        int column=A[0].length;

        //新建一个矩阵B，表示矩阵A的转置
        int [][] B=new int[column][row];
        for(int i=0;i<column;i++)
        {
            for(int j=0;j<row;j++)
            {
                B[i][j]=A[j][i];
            }
        }
        return B;
    }

}
 

5.总结

在笔试面试中大家遇到问题首先不要慌，相信自己肯定可以做出来，然后的话在草稿本上进行演算，实在不行可以求面试官给点提示，最后如果对实现代码有困难或者没有时间的话把思路将给面试官听，总之一句话让面试官看到你的潜力与可能性。加油！！！

6.个人推广

博客地址
https://blog.csdn.net/weixin_41563161
掘金https://juejin.cn/user/2814360172369271

知乎https://www.zhihu.com/people/hai-kuo-tian-kong-63-38-21