【矩阵运算和Java二维数组对矩阵常见运算的实现】

0.前言

本篇文章主要总结了矩阵的常见运算，以及Java中利用二维数组进行运算的实现

1.矩阵运算

1.矩阵加法

1. 运算前提：多个矩阵的行数和列数相同，我们称它们为同型矩阵，只有是同型矩阵才能进行加减运算。
2. 运算规则：两个矩阵相同位置的元素进行相加。

$$\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]+\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]=\left[\begin{array}{ccc}2& 4& 6\\ 8& 10& 12\end{array}\right]$$

2.矩阵减法

1. 运算规则：同矩阵加法，对应元素相减即可。

3.矩阵乘法

1. 运算前提：两个矩阵的乘法仅当第一个矩阵的列数和另一个矩阵的行数相等。
2. 运算规则：两个矩阵，第一个矩阵的行和第二个矩阵的列对应元素相乘再相加，m 行 n 列的矩阵 * n 行 k 列的矩阵，得到一个 m 行 k 列的矩阵。
   $$\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]\ast \left[\begin{array}{cc}1& 2\\ 3& 4\\ 5& 6\end{array}\right]=\left[\begin{array}{cc}1\ast 1+2\ast 3+3\ast 5=22& 1\ast 2+2\ast 4+3\ast 6=28\\ 4\ast 1+3\ast 5+6\ast 5=49& 4\ast 2+5\ast 4+6\ast 6=64\end{array}\right]=\left[\begin{array}{cc}22& 28\\ 49& 64\end{array}\right]$$

4.矩阵转置

1. 运算规则：将矩阵的第 i 行 第 j 列 转换为 第 j 行 第 i 列
   $${\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]}^T=\left[\begin{array}{cc}1& 4\\ 2& 5\\ 3& 6\end{array}\right]$$

2.Java实现

public class Matrix {
    public static void main(String[] args) {
        int[][] a = {{1, 2, 3}, {4, 5, 6}};
        int[][] b = {{1, 2}, {3, 4}, {5, 6}};

        System.out.println(Arrays.deepToString(randomMatrix(3, 2)));
    }

    /**
     * 生成随机矩阵 m行n列
     * @return
     */
    public static int[][] randomMatrix(int m, int n){
        int[][] ans = new int[m][n];
        // 生成随机矩阵
        Random rand = new Random();
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++) {
                ans[i][j] = rand.nextInt(10);
            }
        return ans;
    }


    /**
     * 矩阵加减法
     */
    public static int[][] addOrSub(int[][] a, int[][] b, boolean isPlus) {
        // 不满足加减法条件
        if (a.length != b.length || a[0].length != b[0].length) return new int[0][0];

        for (int i = 0; i < a.length; i++)
            for (int j = 0; j < a[0].length; j++) {
                if (isPlus)
                    a[i][j] += b[i][j];
                else
                    a[i][j] -= b[i][j];
            }
        return a;
    }

    /**
     * 矩阵乘法
     */
    public static int[][] multiply(int[][] a, int[][] b) {
        int m = a.length;
        int n = a[0].length;
        int n1 = b.length;
        int k = b[0].length;
        // 不满足乘法条件
        if (n != n1) return new int[0][0];

        // 构建一个 m 行 k 列的矩阵
        int[][] ans = new int[m][k];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < k; j++) {
                int temp = 0;
                for (int l = 0; l < n; l++) {
                    temp += a[i][l] * b[l][j];
                }
                ans[i][j] = temp;
            }
        }
        return ans;
    }

    /**
     * 转置
     */
    public static int[][] zhi(int[][] a) {
        int m = a.length;
        int n = a[0].length;
        int[][] ans = new int[n][m];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                ans[i][j] = a[j][i];
        return ans;
    }
}