Java进阶(四十九)实现矩阵秩的求解-转置-行列式-逆矩阵操作_矩阵求秩代码(1)

react和vue的比较

相同
1）vitual dom
2）组件化
3）props，单一数据流

不同点
1）react是jsx和模板；（jsx可以进行更多的js逻辑和操作）
2）状态管理（react）
3）对象属性（vue）
4）vue：view——medol之间双向绑定
5）vue：组件之间的通信（props，callback，emit）

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

package cn.edu.ujn.paper.matrix;

public class MatrixUtil {
	
    /\*\*
 \* 实现矩阵相乘 (AB)
 \* @param a 矩阵A
 \* @param b 矩阵B
 \*/
    private static double[][] matrixMulti(double[][] a,double[][] b){
 
    	double c[][] = new double[a.length][b[0].length];
          
        int x,i,j;
        for(i = 0;i<a.length ;i++)
        {  
            for(j = 0;j<b[0].length;j++)
            {  
                int temp = 0;
                for(x = 0;x<b.length;x++)
                {  
                    temp+=a[i][x]\*b[x][j];
                      
                }  
                c[i][j] = temp;
                  
            }  
        }  
        System.out.println("矩阵相乘后结果为：");  
        for(int m = 0; m < a.length; m++)  
        {  
            for(int n = 0; n < b[0].length; n++)  
            {  
                System.out.print(c[m][n]+"\t");
            }  
            System.out.println();  
        }
        
        MatrixUtil.getHL(c);
        
		return c;  
    }
    
	/\*\*
 \* 矩阵打印
 \* @param matrix 矩阵
 \* @param r 行
 \* @param c 列
 \*/
	public static void printMatrix(double[][] matrix, int r, int c){
		System.out.println("打印矩阵：");
		String Strr = new String("");
		for (int i = 0; i < r; i++) {
			for (int j = 0; j < c; j++) {
				String str = String.valueOf(matrix[i][j]);
				Strr += str;
				Strr += "\t";
			}
			Strr += "\n";
		}
		
		System.out.println(Strr);
	}
	
	/\*\*
 \* 求解代数余子式
 \* @param data 原始矩阵
 \* @param h 待求解元素的行
 \* @param v 待求解元素的列
 \* @return
 \*/
    public static double[][] getDY(double[][] data, int h, int v) {  
        int H = data.length;  
        int V = data[0].length;  
        
        double[][] newData = new double[H - 1][V - 1];  
  
        for (int i = 0; i < newData.length; i++) {
  
            if (i < h - 1) {  
                for (int j = 0; j < newData[i].length; j++) {
                    if (j < v - 1) {
                        newData[i][j] = data[i][j];
                    } else {
                        newData[i][j] = data[i][j + 1];
                    }
                }
            } else {
                for (int j = 0; j < newData[i].length; j++) {
                    if (j < v - 1) {
                        newData[i][j] = data[i + 1][j];
                    } else {
                        newData[i][j] = data[i + 1][j + 1];
                    }
                }
  
            }
        }
        
// System.out.println("---------------------代数余子式测试---------------------------------");
        
/\* for(int i = 0; i < newData.length; i++){ 
 for(int j = 0; j < newData[i].length; j++){ 
 System.out.print("newData[" + i + "]" + "[" + j + "]=" + newData[i][j] + " "); 
 } 
 
 System.out.println(); 
 }\*/
  
        return newData;  
    }  	
	
	/\*\* 
 \* 求解行列式的模
 \* 
 \* @param data 
 \* @return float
 \*/  
    public static double getHL(double[][] data) {  
  
        // 终止条件 
        if (data.length == 2) {
            return data[0][0] \* data[1][1] - data[0][1] \* data[1][0];
        }
        
        if (data.length == 1) {
            return data[0][0];
        }
  
        double total = 0;
        // 根据data 得到行列式的行数和列数
        int num = data.length;
        // 创建一个大小为num 的数组存放对应的展开行中元素求的的值
        double[] nums = new double[num];
  
        for (int i = 0; i < num; i++) {
            if (i % 2 == 0) {
                nums[i] = data[0][i] \* getHL(getDY(data, 1, i + 1));
            } else {
                nums[i] = -data[0][i] \* getHL(getDY(data, 1, i + 1));
            }
        }
        
        for (int i = 0; i < num; i++) {  
            total += nums[i];  
        }
        
// System.out.println("total=" + total);
        return total;  
    }  
    
    /\*\* 
 \* 取得转置矩阵 
 \* @param A 
 \* @return float[][] 
 \*/  
    public static double[][] getA\_T(double[][] A) {  
        int h = A.length;  
        int v = A[0].length;  
        // 创建和A行和列相反的转置矩阵 
        double[][] A_T = new double[v][h];  
        // 根据A取得转置矩阵A\_T 
        for (int i = 0; i < h; i++) {  
            for (int j = 0; j < v; j++) {  
                A_T[j][i] = A[i][j];  
            }  
        }  
// System.out.println("取得转置矩阵 wanbi........");
        return A_T;  
    }  
    
    /\*\* 
 \* 求解逆矩阵
 \* 
 \* @param data 
 \* @return 
 \*/  
    public static double[][] getReverseMatrix(double[][] data) {
    	
        // 1.求出行列式的模|data| 
    	double m = getHL(data);  
    	
    	// 若行列式的值为0，则表明逆矩阵不存在
    	if(Arith.compareTo(m, 0) == 0){
    		System.out.println("----------------行列式的模为0，逆矩阵不存在-----------------");
    		return null;
    	}
    	
    	if(m == 0){
    		
    	}
    	
    	System.out.println("行列式:" + m);
    	
        // 创建一个等容量的逆矩阵 
    	double[][] newData = new double[data.length][data.length];
  
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data.length; j++) {
            	double num;
                if ((i + j) % 2 == 0) {
                    num = getHL(getDY(data, i + 1, j + 1));
                } else {
                    num = -getHL(getDY(data, i + 1, j + 1));
                }
  
                newData[i][j] = num / m;
            }
        }
  
        // 2.转置代数余子式
        newData = getA\_T(newData);
        
        // 打印
        System.out.println("逆矩阵：");
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data.length; j++) {
                System.out.print("newData[" + i + "][" + j + "]= " + newData[i][j] + " ");
            }
  
            System.out.println();
        }
  
        return newData;
    }  
    	
    /\*\*
 \* 计算矩阵的秩
 \* @param Matrix 矩阵
 \* @param error\_
### 总结

**前端资料汇总**

**[开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】](https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0)**

![](https://img-blog.csdnimg.cn/img_convert/6e0ba223f65e063db5b1b4b6aa26129a.png)

*   框架原理真的深入某一部分具体的代码和实现方式时，要多注意到细节，不要只能写出一个框架。

*   算法方面很薄弱的，最好多刷一刷，不然影响你的工资和成功率😯



*   在投递简历之前，最好通过各种渠道找到公司内部的人，先提前了解业务，也可以帮助后期优秀 offer 的决策。

*   要勇于说不，对于某些 offer 待遇不满意、业务不喜欢，应该相信自己，不要因为当下没有更好的 offer 而投降，一份工作短则一年长则 N 年，为了幸福生活要慎重选择！！！
    喜欢这篇文章文章的小伙伴们点赞+转发支持，你们的支持是我最大的动力！


分具体的代码和实现方式时，要多注意到细节，不要只能写出一个框架。

*   算法方面很薄弱的，最好多刷一刷，不然影响你的工资和成功率😯



*   在投递简历之前，最好通过各种渠道找到公司内部的人，先提前了解业务，也可以帮助后期优秀 offer 的决策。

*   要勇于说不，对于某些 offer 待遇不满意、业务不喜欢，应该相信自己，不要因为当下没有更好的 offer 而投降，一份工作短则一年长则 N 年，为了幸福生活要慎重选择！！！
    喜欢这篇文章文章的小伙伴们点赞+转发支持，你们的支持是我最大的动力！