矩阵(二维数组)的基本操作：加减乘+从内至外/从外至内的顺/逆时针遍历

常规唠嗑

• 就一个问题：二维数组是矩阵，这有错吗？感慨一下：程序媛和男妇产科医生，好像都挺惨
  的。
• 我突然知道一个之前的一个业务怎么做更好了。小班同学上课，应该怎么给老师排课？这里边其实有2个固定的轴，一个是周一至周日7天，一个是0-24点24个钟头。把一个老师所有的空余时间排成一个724矩阵A，再把同学们的上课时间要求排成一个724矩阵B，然后两个矩阵相加或者相减，就能得出一个课表。例如：老师的可以排课 设为 1，老师可以排课但已经排课 设为 2，老师不可以排课 设为 -1；同学们要开课 设为 1，同学们不开课 设为 -1。然后两个矩阵相减，矩阵A-矩阵B，拿到结果矩阵为0的，就是目标值。

矩阵的基本遍历

    /**
     * 矩阵逐行遍历-默认非空
     * @param matrix 矩阵
     */
    private static void printMatrix(int[][] matrix){
        //行数
        int n = matrix.length;
        //列数
        int m = matrix[0].length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }

矩阵转置

  /**
     * 转置矩阵-默认非空
     * @param matrix 待转置矩阵
     * @return 转置后矩阵
     */
    private static int[][] transpose(int[][] matrix){

        //行数
        int n = matrix.length;
        //列数
        int m = matrix[0].length;
        //转换后矩阵
        int[][] arr = new int[m][n];
        //转置
        System.out.println("-------------初始矩阵-------------");
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                arr[j][i] = matrix[i][j];
                System.out.print(matrix[i][j]+" ");
            }
            System.out.println();
        }

        System.out.println("-------------转置矩阵-------------");
        //输出
        printMatrix(arr);
        
        return arr;
    }

矩阵相加减

    /**
     * 矩阵相加减—两个矩阵大小相同，默认非空
     * @param matrixA 矩阵A
     * @param matrixB 矩阵B
     * @param plus true 执行矩阵相加，false 执行矩阵相减
     * @return 加减结果值
     */
    private static int[][] plusOrSub(int[][] matrixA, int[][] matrixB, Boolean plus){

        // 行数
        int n = matrixA.length;
        // 列数
        int m = matrixA[0].length;
        // 结果矩阵
        int[][] arr = new int[n][m];

        System.out.println("----------------matrixA-------------");
        printMatrix(matrixA);
        System.out.println("----------------matrixB-------------");
        printMatrix(matrixB);

        // 运算
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if(plus){
                    arr[i][j] = matrixA[i][j]+matrixB[i][j];
                    System.out.print(matrixA[i][j]+"+"+matrixB[i][j]+"="+arr[i][j]+" ");
                }else{
                    arr[i][j] = matrixA[i][j]-matrixB[i][j];
                    System.out.print(matrixA[i][j]+"-"+matrixB[i][j]+"="+arr[i][j]+" ");
                }
            }
            System.out.println();
        }

        System.out.println("----------------运算后矩阵--------------");
        printMatrix(arr);

        return arr;
    }

矩阵相乘

    /**
     * 矩阵相乘-当矩阵A的列数等于矩阵B的行数时，A与B可以相乘，默认非空
     * @param matrixA A
     * @param matrixB B
     * @return 相乘矩阵-行数等于矩阵A的行数，列数等于B的列数
     */
    private static int[][] mul(int[][] matrixA,int[][] matrixB){

        System.out.println("----------------matrixA-------------");
        printMatrix(matrixA);
        System.out.println("----------------matrixB-------------");
        printMatrix(matrixB);
        // 行数
        int n=matrixA.length;
        // 列数
        int m= matrixB[0].length;
        // 结果矩阵
        int[][] arr = new int[n][m];

        // B的行数
        int bn = matrixB.length;
        // A的列数
        int am = matrixA[0].length;

        // 运算
        System.out.println("----------------矩阵相乘-------------");
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                for(int k=0;k<am;k++){
                    arr[i][j] = matrixA[i][k]*matrixB[k][j]+arr[i][j];
                    if(k+1==am){
                        System.out.print(matrixA[i][k]+" * "+matrixB[k][j]);
                    }else{
                        System.out.print(matrixA[i][k]+" * "+matrixB[k][j]+ " + ");
                    }
                }
                System.out.print(",");
            }
            System.out.println();
        }

        System.out.println("----------------矩阵相乘结果-------------");
        printMatrix(arr);

        return arr;
    }

矩阵的顺时针遍历-从外至内

/**
 * 从外围顺时针遍历矩阵-默认非空
 * 3 6 0 7 8
 * 3 5 9 1 0
 * 0 6 7 8 9
 * 1 2 3 4 5
 * @param matrix 矩阵
 */
private static void clockwisePrintMatrixFromOuterToInner(int[][] matrix){

    // 行数
    int n = matrix.length;
    // 列数
    int m = matrix[0].length;

    int[] arr = new int[n*m];
    int arrIndex = 0 ;

    // 边界值
    int left=0,right=m-1,up=0,down=n-1;

    // 6，设置循环条件
    while (left<=right && up<=down){
        // 1，从上左到上右 3->8
        for(int lr=left;lr<=right;lr++){
            arr[arrIndex] = matrix[left][lr];
            arrIndex++;
        }
        // 2，从右上到右下 8->5
        if(up<down){
            for(int ud=up+1;ud<=down;ud++){
                arr[arrIndex]=matrix[ud][right];
                arrIndex++;
            }
        }
        // 3，从下右到下左 5->1
        if(up<down && left<right){
            for(int rl=right-1;rl>=left;rl--){
                arr[arrIndex]=matrix[down][rl];
                arrIndex++;
            }
        }
        // 4，从左下到左上 1->3
        if(up<down && left<right){
            for(int du=down-1;du>up;du--){
                arr[arrIndex] = matrix[du][left];
                arrIndex++;
            }
        }

        // 5，设置循环内围的边界值
        left++;right--;up++;down--;
    }

    // 7，打印最终结果
    for(int i = 0 ;i <m*n;i++){
        System.out.print(arr[i]+" ");
    }
}

矩阵的逆时针遍历-从外至内

    /**
     * 从外围逆时针遍历矩阵-默认非空
     * 3 6 0 7 8
     * 3 5 9 1 0
     * 0 6 7 8 9
     * 1 2 3 4 5
     * @param matrix 矩阵
     */
    private static void anticlockwisePrintMatrixFromOuterToInner(int[][] matrix){

        // 行数
        int n = matrix.length;
        // 列数
        int m = matrix[0].length;

        // 边界值
        int left=0,right=m-1,up=0,down=n-1;

        int[] arr = new int[n*m];
        int arrIndex = 0 ;

        // 6，设置循环条件
        while (left<=right && up<=down){
            // 1，从上左到左下 3->1
            for(int ud=up;ud<=down;ud++){
                arr[arrIndex] = matrix[ud][left];
                arrIndex++;
            }
            // 2，从下左到下右 1->5
            if(up<down) {
                for (int lr = left + 1; lr <= right; lr++) {
                    arr[arrIndex] = matrix[down][lr];
                    arrIndex++;
                }
            }
            // 3，从右下到右上 5->8
            if(up<down && left < right) {
                for (int du = down - 1; du >= up; du--) {
                    arr[arrIndex] = matrix[du][right];
                    arrIndex++;
                }
            }
            // 4，从右上到左上 8->3
            if(up<down && left <right)
                for(int rl=right-1;rl>left;rl--){
                    arr[arrIndex] = matrix[up][rl];
                    arrIndex++;
                }


            // 5，设置循环内围的边界值
            left++;right--;up++;down--;
        }

        // 7，打印最终结果
        for(int i = 0 ;i <m*n;i++){
            System.out.print(arr[i]+" ");
        }

    }

矩阵的顺时针遍历-从内至外

    /**
     * 从内围顺时针遍历矩阵-默认非空
     * 3 6 0 7 8
     * 3 5 9 1 0
     * 0 6 7 8 9
     * 1 2 3 4 5
     * @param matrix 矩阵
     */
    private static void clockwisePrintMatrixFromInnerToOuter(int[][] matrix){

        printMatrix(matrix);
        System.out.println("--------------matrix-------------");
        // 行数
        int n = matrix.length;
        // 列数
        int m = matrix[0].length;

        int executeTimesN=(n+1)/2;
        int executeTimesM=(m+1)/2;
        // 需要完整执行的次数
        int executeTimes = executeTimesN>executeTimesM?executeTimesM:executeTimesN;

        int[] arr = new int[n*m];
        int arrIndex = 0 ;

        // 1，确认内环边界值
        int left = executeTimes-1,up = executeTimes-1,right = m-executeTimes,down=n-executeTimes;

        // 6，设置循环条件
        while (left>=0 && up>=0){
            // 1，从上左到上右 5->1
            for(int lr=left;lr<=right;lr++){
                arr[arrIndex] = matrix[left][lr];
                arrIndex++;
            }
            // 2，从右上到右下 1->8
            if(up<down){
                for(int ud=up+1;ud<=down;ud++){
                    arr[arrIndex]=matrix[ud][right];
                    arrIndex++;
                }
            }
            // 3，从下右到下左 8->6
            if(up<down && left<right){
                for(int rl=right-1;rl>=left;rl--){
                    arr[arrIndex]=matrix[down][rl];
                    arrIndex++;
                }
            }
            // 4，从左下到左上 6->6
            if(up<down && left<right){
                for(int du=down-1;du>up;du--){
                    arr[arrIndex] = matrix[du][left];
                    arrIndex++;
                }
            }

            // 5，设置循环内围的边界值
            left--;right++;up--;down++;
        }

        // 7，打印最终结果
        for(int i = 0 ;i <m*n;i++){
            System.out.print(arr[i]+" ");
        }
    }

矩阵的逆时针遍历-从内至外

• 不贴代码了，结合从内到外的顺时针遍历和从外到内的逆时针遍历，copy 一部分，然后paste就阔以了。