矩阵乘法（java实现）

最新推荐文章于 2023-11-10 08:22:39 发布
最新推荐文章于 2023-11-10 08:22:39 发布
阅读量1.7w 收藏 64
点赞数 14
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kigznlun/article/details/79942950
版权

 矩阵的运算中经常要用到矩阵的乘法，通常情况下矩阵的乘法用计算机高级语言来实现有三种办法。

  第一种是最普通的，最容易想到的办法，即用三个for循坏来实现。它的时间复杂度为O(n^3)。具体实现如下：

public class Matrixmultiply {

	public static void main(String[] args) {
		
        int A[][] = new int[][] {  
            {1, 1, 1, 1, 1, 1, 1, 1},  
            {2, 2, 2, 2, 2, 2, 2, 2},  
            {3, 3, 3, 3, 3, 3, 3, 3},  
            {4, 4, 4, 4, 4, 4, 4, 4},  
            {5, 5, 5, 5, 5, 5, 5, 5},  
            {6, 6, 6, 6, 6, 6, 6, 6},  
            {7, 7, 7, 7, 7, 7, 7, 7},  
            {8, 8, 8, 8, 8, 8, 8, 8},  
        };  
          
         int B[][] = new int[][] {  
            {8,8,8,8,8,8,8,8},  
            {7,7,7,7,7,7,7,7},  
            {6,6,6,6,6,6,6,6},  
            {5,5,5,5,5,5,5,5},  
            {4,4,4,4,4,4,4,4},  
            {3,3,3,3,3,3,3,3},  
            {2,2,2,2,2,2,2,2},  
            {1,1,1,1,1,1,1,1},  
        };
      int[][] C = new int[8][8];
      for(int i=0;i<8;i++){
    	  for(int j=0;j<8;j++){
    		  for(int k=0;k<8;k++){
    			  C[i][j] =C[i][j] + A[i][k] * A[k][j];
    		  }
    	  }
      }
      System.out.println("普通矩阵乘法");
      for(int i=0;i<8;i++){
     	 for(int j=0;j<8;j++){
     		 System.out.print(C[i][j] + " ");
     	 }
     	 System.out.println();
      }	
	}
}

你最初可能觉得任何矩阵乘法都要花费这么多时间，因为矩阵乘法的自然定义就是如此。但这是错误的，如果用分治的思想，看看我们能不能将其时间复杂度简化。

为简单起见，用分治法时我们假定三个矩阵均为n*n矩阵，其中n为2的幂。

在计算C11等矩阵时，我们又遇到了两个矩阵相乘所以可以用递归来解决。这个程序的时间复杂度为T(n)=8T(n/2)+O(n^2)。因为每次递归都需要做八次乘法，因此为8T(n/2)。同时我们还要计算四次矩阵加法，每个矩阵包含n^2/4个元素，因此为O(n^2)。所以它的递归式为：

  可以用递归树的方法求得其时间复杂度仍为O(n^3)。其代码实现为

public class Recursivematrixmultiply {
	   public static void displayMatrix(int matrix[][]) { 
	    	int n = matrix.length;
	        for (int i=0;i<n; i++) {  
	            for (int j=0;j<n;j++) {  
	                System.out.print(matrix[i][j] + " ");  
	            }  
	            System.out.println();  
	        }  
	    }  
		
	    public static void copyToMatrix(int srcMatrix[][], int startI, int startJ,   
	            int destMatrix[][]) { 
	    	int n = destMatrix.length;
	        for (int i = startI; i < startI+n; i++) {  
	            for (int j = startJ; j <startJ+n ; j++) {  
	                destMatrix[i - startI][j - startJ] = srcMatrix[i][j];   
	            }  
	        }  
	    } 
	    public static void copyFromMatrix(int destMatrix[][], int startI, int startJ,  
	            int srcMatrix[][]) {  
	    	int n = srcMatrix.length;
	        for (int i = 0; i < n; i++) {  
	            for (int j = 0; j < n; j++) {  
	                destMatrix[startI + i][startJ + j] = srcMatrix[i][j];   
	            }  
	        }  
	    } 
	    public static void MatrixAdd(int A[][],int B[][],int C[][]){
	        int n = A.length;
	    	for(int i=0;i<n;i++){
	    		for(int j=0;j<n;j++){
	    			C[i][j] = A[i][j] + B[i][j];
	    		}
	    	}	
	    }
	    public static void MatrixSub(int A[][], int B[][], int C[][]) {  
	    	int n = A.length;
	        for (int i=0;i<n;i++) {  
	            for (int j=0;j<n;j++) {  
	                C[i][j] = A[i][j] - B[i][j];  
	            }  
	        }  
	    } 
		  
	      
	    public static int[][] squareMatrixMultiplyRecursive(int A[][], int B[][]) {  
	        int n = A.length;  
	        int C[][] = new int[n][n];  
	        if (n == 1) {  
	            C[0][0] = A[0][0] * B[0][0];  
	        } else {  
	            int A11[][], A12[][], A21[][], A22[][];  
	            int B11[][], B12[][], B21[][], B22[][];  
	            int C11[][], C12[][], C21[][], C22[][];  
	              
	            A11 = new int[n/2][n/2];A12 = new int[n/2][n/2];A21 = new int[n/2][n/2];A22 = new int[n/2][n/2];  
	            copyToMatrix(A, 0, 0, A11);  
	            copyToMatrix(A, 0, n/2,  A12);  
	            copyToMatrix(A, n/2, 0,  A21);  
	            copyToMatrix(A, n/2, n/2, A22);  
	              
	            B11 = new int[n/2][n/2];B12 = new int[n/2][n/2];B21 = new int[n/2][n/2];B22 = new int[n/2][n/2];  
	            copyToMatrix(B, 0, 0, B11);  
	            copyToMatrix(B, 0, n/2, B12);  
	            copyToMatrix(B, n/2, 0, B21);  
	            copyToMatrix(B, n/2, n/2, B22);  
	              
	            C11 = new int[n/2][n/2];C12 = new int[n/2][n/2];C21 = new int[n/2][n/2];C22 = new int[n/2][n/2];  
	            MatrixAdd(squareMatrixMultiplyRecursive(A11, B11), squareMatrixMultiplyRecursive(A12, B21),  
	                    C11);  
	            MatrixAdd(squareMatrixMultiplyRecursive(A11, B12), squareMatrixMultiplyRecursive(A12, B22),  
	                    C12);  
	            MatrixAdd(squareMatrixMultiplyRecursive(A21, B11), squareMatrixMultiplyRecursive(A22, B21),  
	                    C21);  
	            MatrixAdd(squareMatrixMultiplyRecursive(A21, B12), squareMatrixMultiplyRecursive(A22, B22),  
	                    C22);  
	            copyFromMatrix(C, 0, 0, C11);  
	            copyFromMatrix(C, 0, n/2, C12);  
	            copyFromMatrix(C, n/2, 0, C21);  
	            copyFromMatrix(C, n/2, n/2, C22);  
	        }  
	          
	        return C;  
	    } 
	    public static void main(String[] args) { 
	         int A[][] = new int[][] {  
	             {1, 1, 1, 1, 1, 1, 1, 1},  
	             {2, 2, 2, 2, 2, 2, 2, 2},  
	             {3, 3, 3, 3, 3, 3, 3, 3},  
	             {4, 4, 4, 4, 4, 4, 4, 4},  
	             {5, 5, 5, 5, 5, 5, 5, 5},  
	             {6, 6, 6, 6, 6, 6, 6, 6},  
	             {7, 7, 7, 7, 7, 7, 7, 7},  
	             {8, 8, 8, 8, 8, 8, 8, 8},  
	         };  
	           
	          int B[][] = new int[][] {  
	             {8,8,8,8,8,8,8,8},  
	             {7,7,7,7,7,7,7,7},  
	             {6,6,6,6,6,6,6,6},  
	             {5,5,5,5,5,5,5,5},  
	             {4,4,4,4,4,4,4,4},  
	             {3,3,3,3,3,3,3,3},  
	             {2,2,2,2,2,2,2,2},  
	             {1,1,1,1,1,1,1,1},  
	         };
       System.out.println("递归矩阵乘法");  
	        int C[][] = squareMatrixMultiplyRecursive(A,B);  
	        displayMatrix(C);    
	    }  
	}

下面我们用strassen方法来求矩阵乘法，它将递归的8次乘法简化为7次。其代价是增加了几次额外的加法，但这对整个算法影响不大。strassen的算法运行时间递归式为

 

可以求出其解为

strassen算法细节如下

首先创建10个矩阵

递归地计算七次乘法计算

最后对P矩阵进行加减法运算

C11=P5+P4-P2+P6

C12=P1+P2

C21=P3+P4

C22=P5+P1-P3-P7

其代码实现为

  public class Strassen {
 
    public static void displayMatrix(int matrix[][]) { 
    int n = matrix.length;
        for (int i=0;i<n; i++) {  
            for (int j=0;j<n;j++) {  
                System.out.print(matrix[i][j] + " ");  
            }  
            System.out.println();  
        }  
    }  

    public static void copyToMatrix(int srcMatrix[][], int startI, int startJ,   
            int destMatrix[][]) { 
    int n = destMatrix.length;
        for (int i = startI; i < startI+n; i++) {  
            for (int j = startJ; j <startJ+n ; j++) {  
                destMatrix[i - startI][j - startJ] = srcMatrix[i][j];   
            }  
        }  
    } 
    public static void copyFromMatrix(int destMatrix[][], int startI, int startJ,  
            int srcMatrix[][]) {  
    int n = srcMatrix.length;
        for (int i = 0; i < n; i++) {  
            for (int j = 0; j < n; j++) {  
                destMatrix[startI + i][startJ + j] = srcMatrix[i][j];   
            }  
        }  
    } 
    public static void MatrixAdd(int A[][],int B[][],int C[][]){
        int n = A.length;
    for(int i=0;i<n;i++){
    for(int j=0;j<n;j++){
    C[i][j] = A[i][j] + B[i][j];
    }
    } 
    }
    public static void MatrixSub(int A[][], int B[][], int C[][]) {  
    int n = A.length;
        for (int i=0;i<n;i++) {  
            for (int j=0;j<n;j++) {  
                C[i][j] = A[i][j] - B[i][j];  
            }  
        }  
    } 

    public static int[][] strassenMatrixMultiplyRecursive(int[][] A,int[][] B){
 int n = A.length;
 int[][] C = new int[n][n];
 if(n==1)
   C[0][0] = A[0][0] * B[0][0];
 else{
 int[][] A11,A12,A21,A22; 
 int[][] B11,B12,B21,B22;
 int[][] S1,S2,S3,S4,S5,S6,S7,S8,S9,S10;
 int[][] P1,P2,P3,P4,P5,P6,P7;
 int[][] C11,C12,C21,C22;
 
 A11 = new int[n/2][n/2];
 A12 = new int[n/2][n/2];
 A21 = new int[n/2][n/2];
 A22 = new int[n/2][n/2];
 copyToMatrix(A,0,0,A11);
 copyToMatrix(A,0,n/2,A12);
 copyToMatrix(A,n/2,0,A21);
 copyToMatrix(A,n/2,n/2,A22);


 B11 = new int[n/2][n/2];
 B12 = new int[n/2][n/2];
 B21 = new int[n/2][n/2];
 B22 = new int[n/2][n/2];
 copyToMatrix(B,0,0,B11);
 copyToMatrix(B,0,n/2,B12);
 copyToMatrix(B,n/2,0,B21);
 copyToMatrix(B,n/2,n/2,B22);
 
 S1 = new int[n/2][n/2];
 S2 = new int[n/2][n/2];
 S3 = new int[n/2][n/2];
 S4 = new int[n/2][n/2];
 S5 = new int[n/2][n/2];
 S6 = new int[n/2][n/2];
 S7 = new int[n/2][n/2];
 S8 = new int[n/2][n/2];
 S9 = new int[n/2][n/2];
 S10 = new int[n/2][n/2];
 MatrixSub(B12,B22,S1);
 MatrixAdd(A11,A12,S2);
 MatrixAdd(A21,A22,S3);
 MatrixSub(B21,B11,S4);
 MatrixAdd(A11,A22,S5);
 MatrixAdd(B11,B22,S6);
 MatrixSub(A12,A22,S7);
 MatrixAdd(B21,B22,S8);
 MatrixSub(A11,A21,S9);
 MatrixAdd(B11,B12,S10);
 
 P1 = new int[n/2][n/2];P2 = new int[n/2][n/2];P3 = new int[n/2][n/2];P4 = new int[n/2][n/2];  
          P5 = new int[n/2][n/2];P6 = new int[n/2][n/2];P7 = new int[n/2][n/2];
          P1 = strassenMatrixMultiplyRecursive(A11, S1);  
          P2 = strassenMatrixMultiplyRecursive(S2, B22);  
          P3 = strassenMatrixMultiplyRecursive(S3, B11);  
          P4 = strassenMatrixMultiplyRecursive(A22, S4);  
          P5 = strassenMatrixMultiplyRecursive(S5, S6);  
          P6 = strassenMatrixMultiplyRecursive(S7, S8);  
          P7 = strassenMatrixMultiplyRecursive(S9, S10);
          
          C11 = new int[n/2][n/2];
          C12 = new int[n/2][n/2];
          C21 = new int[n/2][n/2];
          C22 = new int[n/2][n/2];
          int[][] temp = new int[n/2][n/2];
          MatrixAdd(P5,P4,temp);
          MatrixSub(temp,P2,temp);
          MatrixAdd(temp,P6,C11);
          
          MatrixAdd(P1, P2, C12);  
          MatrixAdd(P3, P4, C21);  
            
          MatrixAdd(P5, P1, temp);  
          MatrixSub(temp, P3, temp);  
          MatrixSub(temp, P7, C22);
          
          copyFromMatrix(C,0,0,C11);
          copyFromMatrix(C,0,n/2,C12);
          copyFromMatrix(C,n/2,0,C21);
          copyFromMatrix(C,n/2,n/2,C22);   
 }
 return C;  
  }
    public static void main(String[] args) { 
         int A[][] = new int[][] {  
            {1, 1, 1, 1, 1, 1, 1, 1},  
            {2, 2, 2, 2, 2, 2, 2, 2},  
            {3, 3, 3, 3, 3, 3, 3, 3},  
            {4, 4, 4, 4, 4, 4, 4, 4},  
            {5, 5, 5, 5, 5, 5, 5, 5},  
            {6, 6, 6, 6, 6, 6, 6, 6},  
            {7, 7, 7, 7, 7, 7, 7, 7},  
            {8, 8, 8, 8, 8, 8, 8, 8},  
        };  
          
         int B[][] = new int[][] {  
            {8,8,8,8,8,8,8,8},  
            {7,7,7,7,7,7,7,7},  
            {6,6,6,6,6,6,6,6},  
            {5,5,5,5,5,5,5,5},  
            {4,4,4,4,4,4,4,4},  
            {3,3,3,3,3,3,3,3},  
            {2,2,2,2,2,2,2,2},  
            {1,1,1,1,1,1,1,1},  
        };
        System.out.println("Strassen 递归矩阵乘法");  
        int[][] C = new int[8][8];
        C = strassenMatrixMultiplyRecursive(A,B);  
        displayMatrix(C);
    }
}

 

白水煮豆腐
关注
  • 14
    点赞
  • 踩
  • 64
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
Java实现的矩阵乘法示例
08-26
Java实现的矩阵乘法示例 矩阵乘法是线性代数中的一种基本操作，它将两个矩阵相乘，得到一个新的矩阵。在Java中，矩阵乘法可以通过循环遍历和数组操作来实现。下面是Java实现的矩阵乘法示例的知识点总结： 一、矩阵...
java 矩阵乘法的mapreduce程序实现
08-30
"java 矩阵乘法的mapreduce程序实现" java 矩阵乘法的mapreduce程序实现是使用Hadoop的MapReduce框架来实现矩阵乘法的操作。矩阵乘法是一种基本的线性代数操作，用于计算两个矩阵的乘积。在大规模数据处理中，矩阵...
用Java实现矩阵乘法
lkllkl123123的博客
07-23 8991
Java实现矩阵乘法
矩阵乘法Java实现
neweastsun的专栏
02-18 6778
本文介绍几种方式实现矩阵相乘。矩阵概念一般语言没有提供，我们首先子句实现，同时也介绍一些现成库实现。 1. 概念介绍 首先通过示例介绍矩阵，首先定义第一个3x2的矩阵： 我们再定义第二个2x3的矩阵： 两个矩阵相乘，结果为3x4矩阵： 计算公式为： 第一个矩阵的列数要和第二个矩阵的行数相等，否则不能相乘。即从A矩阵的第一行开始依次和B矩阵的每列相乘，每行与列元素相乘的结果相加作为结果矩阵的一个元素。 2. 矩阵乘法实现 2.1 自己实现 首先我们自己实现矩阵相乘，为了简单我们使用二维double类型
java矩阵3x3_用java编写：键盘输入一个3x3的矩阵,求他的自身相乘的乘积并输出得到的矩阵；最后得到的是矩阵哦...
weixin_39990250的博客
02-13 1432
展开全部lz 你好这种纯粹是数学问题 搞清楚线代中矩阵乘积的过32313133353236313431303231363533e4b893e5b19e31333332616532程 就能编出来以下是我帮你写的代码(ps：有两个方法multi() 用单个变量保存元素的值multiInArray() 用数组保存元素的值 这种方式是为了你好懂乘积的过程运行结果都是一样的 只是保存方式)i...
矩阵乘法 java_Java实现矩阵乘法以及优化的方法实例
weixin_39663729的博客
02-20 466
传统的矩阵乘法实现首先，两个矩阵能够相乘，必须满足一个前提：前一个矩阵的行数等于后一个矩阵的列数。第一个矩阵的第m行和第二个矩阵的第n列的乘积和即为乘积矩阵第m行第n列的值，可用如下图像表示这个过程。矩阵乘法过程展示C[1][1] = A[1][0] * B[0][1] + A[1][1] * B[1][1] + A[1][2] * B[2][1] + A[1][3] * B[3][1] + A[...
java 二维数组矩阵乘法的实现方法
09-05
java 二维数组矩阵乘法的实现方法，需要的朋友可以参考一下
矩阵乘法的java实现
09-20
矩阵乘法的java实现，希望对大家有用。
算法设计与分析实验 Strassen矩阵乘法 java实现
12-06
Strassen矩阵乘法是一种高效的矩阵乘法算法，由德国数学家Günther Strassen在1969年提出。这个算法通过将大矩阵分解为小矩阵，然后递归地进行运算，大大减少了乘法操作的数量，尤其是在处理大规模矩阵时，其时间...
java编程实现两个任意的矩阵相乘
12-22
实现自由输入规范的两个矩阵相乘，能够很好的实现这个功能
矩阵加减乘除java实现
03-19
矩阵减减乘除java实现
两个矩阵相乘的算法之java
04-02
java编写的两个矩阵相乘的算法，打包文件，class
Java学习之矩阵乘法
weixin_47062907的博客
03-14 658
一、基本知识 我们知道使用二维数组可以计算两个矩阵的乘积。如果矩阵A乘以矩阵B得到了矩阵C，那么就必须满足以下要求： （1）矩阵A 的列数=矩阵B的行数。 （2）矩阵C的行数=矩阵A的行数，矩阵C的列数=矩阵B的列数。 例如下面这道题目： 我们知道，第一行第一列的数=1x0+1x1=1，以此类推即可完成矩阵乘法的计算。我们就用上面这个题目作为案例进行编码。 二、案例效果图： 三、案例代码： public class Juzhenchengfa { public static void main(Str
练习-Java数组之二维数值数组之矩阵乘
最新发布
weixin_74284876的博客
11-10 172
仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 间编写程序代码，给定以下两个矩阵，求它们的乘积。从图 1 可以看到，相乘后的矩阵的行数等于第一个矩阵的行数，列数等于第二个矩阵的列数。平台将运行你编写的程序代码，若你的运行结果与预期输出一致，则通关。本关任务：给定两个矩阵，求它们的乘积。
快速排序的java实现，快速排序的原理理解，快速排序平均时间复杂度为什么是O（nlogn）。快速排序最坏时间复杂度为什么是O(n^2)，快速排序最坏情况是什么样的，快排最坏情况的的举例
SacredOath的博客
09-19 2770
1. 快速排序原理理解： 通过指针交换，所有大的数都去了右（左）半区，所有小的数都去了左（右）半区，那么中间自然就是基准值恰好应处在的准确索引。 （以下是具体操作流程： 1.第一个元素作为基准值。 2.在最左边和最右边各设置一个虚拟指针，左指针一格格向右移动，右指针一格格向左移动。 3.每当左指针指向比基准值大的数就停下，每当右指针指向比基准值小的数就停下。 4.两个指针停下后，交换两个指针指的数。这时，大的数就会跑到右边，小的数就会跑到左边 5.一直这样移动、停下、交换、移动、停下、交换、移动、…，直到两
Java矩阵乘法
gy99csdn的博客
01-07 1362
输入一个 mn的矩阵 和一个np的矩阵，并初始化, 要求打印出两个矩阵的乘积。 package com.company; import java.util.Arrays; import java.util.Random; import java.util.Scanner; /** * @Author:gaoyuan * @Description:矩阵乘积 * @DateTime:2021/1/6 22:38 **/ public class MatrixMultip { public s
Java实现矩阵乘法——两个矩阵相乘
qwqc262的博客
10-13 2090
矩阵乘法 根据矩阵乘法规则，如a[4,3]×b[3,2]将会产生一个r[4,2]的新矩阵，r[i][j]=a[i][0]×b[0][j]+a[i][1]×b[1][j]+a[i][2]×b[2][j]。 下面为源代码： package 课本例题第三章数组; public class Example_3_4 { public void multiply(int[][]a,int[][]b) { int[][]r=new int [4][2];//数组r用于存放选算结果 int tmp=0; f
使用Java中的方法写矩阵相乘
qq_61921355的博客
10-12 356
使用Java中的方法写矩阵相乘
使用类计算两个矩阵的乘积[JAVA]
weixin_61165727的博客
01-05 595
使用类计算两个矩阵的乘积[JAVA]。编写一个能进行矩阵乘法运算的程序。A×B，当A的列数和B的行数相同时，能进行矩阵运算。本程序的主类源文件（Test.java）已经创建好了。
用java实现矩阵乘法
09-21
可以使用Java中的矩阵库来实现矩阵乘法。根据提供的引用内容，有两种方法可以实现矩阵相乘。 方法一： 利用Jama库中的Matrix类来进行矩阵乘法。首先，将两个矩阵实例化为Matrix对象，然后使用multiply()方法进行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值