3

矩阵相乘

package Q1;
import java.util.Arrays;

public class MatrixMultiple {
    public static void main(String[] args){
        int[][] m1 ={{1,2}, {3,4}, {5,6}};
        int[][] m2 ={{1,2,3}, {4,5,6}};
        int[][] m3 = new int[m1.length][m2[0].length];
        for (int i = 0; i < m1.length; i++)//mn矩阵的m行
            for (int j = 0; j < m2[0].length; j++)//np矩阵的p列
                for (int k = 0; k < m1[0].length; k++)//mn矩阵的n列（np矩阵的n行）
                    m3[i][j] += m1[i][k] * m2[k][j];
        for (int i = 0; i < m1.length; i++) {
            System.out.println(Arrays.toString(m3[i]));
        }

    }
}

创建并打印三维数组

package Q2;

import java.util.Arrays;

public class ThreeD {
    public static void main(String[] args){
        int[][][] m = new int[3][3][3];
        for (int i = 0; i < m.length; i++) {
            for (int j = 0; j < m[0].length; j++) {
                for (int k = 0; k < m[0][0].length; k++) {
                    m[i][j][k] = i*100 + j*10 + k;//k表示一维，j表示2维，i表示三维
                }
            }
        }
        for (int i = 0; i < m.length; i++) {
            for (int j = 0; j < m[0].length; j++) {
                for (int k = 0; k < m[0][0].length; k++) {
                    System.out.print(m[i][j][k] + " ");
                }
                System.out.println();
            }
            System.out.println();
        }
    }
}

顺时针遍历

package Q3;

import java.util.Arrays;

public class ClockwiseOutput {
    public static void main(String[] args) {
        int[][] m = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
        System.out.println(Arrays.toString(spiralOrder(m)));
    }


    /**
     * 该方法实现 按照顺时针顺序打印数组的值，这里给大家的这种解法是比较好理解的
     * <p>
     * 定义四个边界：上（top）、下（down）、左（left）、右（right），坐标需要在边界内进行遍历。
     * <p>
     * 定义一个长度为2的数组 direction 指定坐标变化的方向，[row, column]为当前的坐标，那么[row + direction[0], column + direction[1]]即为坐标的下一个位置。通过这种方式，只要注意更新 direction 即可
     * <p>
     * 坐标每遍历到一个角落，direction就应该发生变化，同时边界也应该发生变化：
     * <p>
     * 遍历到右上角，此时direction应该变为向下，上边界应该增加1
     * 遍历到右下角，此时direction应该变为向左，右边界应该减少1
     * 遍历到左下角，此时direction应该变为向上，下边界应该减少1
     * 遍历到左上角，此时direction应该变为向右，左边界应该增加1
     * 怎么判断是否到达哪个角落呢？
     * <p>
     * 可以通过坐标和边界值以及方向来判断
     * <p>
     * 比如如果到达了右上角。此时横坐标应该等于right，因为是顺时针遍历，所以纵坐标应该等于top，且方向应该为向右。
     */
    public static int[] spiralOrder(int[][] matrix) {
        if (matrix.length == 0) {
            return new int[]{};
        }
        int totalNumber = matrix.length * matrix[0].length;
        //结果数组，按照顺时针访问矩阵的顺序，存放矩阵元素
        int[] ret = new int[totalNumber];
        //index指向结果数组中，按照顺时针访问的下一个矩阵元素的值，在结果数组中存放的位置
        int index = 0;
        //上边界
        int top = 0;
        //下边界(矩阵最后一行的索引)
        int down = matrix.length - 1;
        //左边界
        int left = 0;
        //右边界
        int right = matrix[0].length - 1;
        //按照顺时针方式，下一步的移动的方式，取值和含义如下
        //(0,1)表示行数不变, 向右移动一个位置
        //(0,-1)表示行数不变，向左移动一个位置
        //(1,0) 表示列数不变，向下移动一个位置
        //(-1,0)表示列数不变，向上移动一个位置
        int[] direction = new int[]{0, 1};

        int row = 0, column = 0;

        int count = (down + 1) * (right + 1);
        //
        while (totalNumber > 0) {
            //把按顺时针顺序访问到的元素，存储到结果集中的第index下标
            ret[index++] = (matrix[row][column]);
            //还没有遍历到的元素个数，少了一个
            totalNumber--;
            if (row == top && column == right && direction[1] == 1) {
                //如果是在水平向右移动的过程中，移动到了右边界，修改移动方向和，上边界的值(这行已经遍历完了)
                direction[0] = 1;
                direction[1] = 0;
                top++;
            } else if (row == down && column == right && direction[0] == 1) {
                //如果是在垂直向下移动的过程中，移动到了下边界，修改移动方向和，右边界(右面这列遍历完了)
                direction[0] = 0;
                direction[1] = -1;
                right--;
            } else if (row == down && column == left && direction[1] == -1) {
                //如果是在水平向左移动的过程中，移动到了左边界，修改移动方向和，下边界的值(下面这行已经遍历完了)
                direction[0] = -1;
                direction[1] = 0;
                down--;
            } else if (row == top && column == left && direction[0] == -1) {
                //如果是在垂直向上移动的过程中，移动到了上边界，修改移动方向和，左边界(左面这列遍历完了)
                direction[0] = 0;
                direction[1] = 1;
                left++;
            }

            //按计算好的顺时针移动方式，移动到一下个位置
            row += direction[0];
            column += direction[1];
        }
        return ret;
    }
}