逆矩阵实现java代码

为了实现Hill密码，我们必须先实现如何求逆矩阵。

A的逆矩阵公式为 A*/|A|，我们需要分别求出A*、|A|。

为了求出我们的伴随矩阵，我们要实现几个步骤的方法：
    1、实现求出（h,v）相应坐标下的余子式
    2、实现求出一个矩阵的值
    3、实现通过求代数余子式并转置来实现求逆矩阵

1、实现求出（h,v）相应坐标下的余子式

/*
     * 求(h,v)坐标的位置的余子式
     */
    public float[][] getConfactor(float[][] data, int h, int v) {
        int H = data.length;
        int V = data[0].length;
        float[][] newdata = new float[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];
                    }
                }
            }
        }

//      for(int i=0; i<newdata.length; i ++)
//          for(int j=0; j<newdata[i].length; j++) {
//              System.out.println(newdata[i][j]);
//          }
        return newdata;
    }

2、实现求出一个矩阵的值

/*
     * 计算行列式的值
     */
    public float getMartrixResult(float[][] data) {
        /*
         * 二维矩阵计算
         */
        if(data.length == 2) {
            return data[0][0]*data[1][1] - data[0][1]*data[1][0];
        }
        /*
         * 二维以上的矩阵计算
         */
        float result = 0;
        int num = data.length;
        float[] nums = new float[num];
        for(int i=0; i<data.length; i++) {
            if(i%2 == 0) {
                nums[i] = data[0][i] * getMartrixResult(getConfactor(data, 1, i+1));
            }else {
                nums[i] = -data[0][i] * getMartrixResult(getConfactor(data, 1, i+1));
            }
        }
        for(int i=0; i<data.length; i++) {
            result += nums[i];
        }

//      System.out.println(result);
        return result;
    }

3、实现通过求代数余子式并转置来实现求逆矩阵

public float[][] getReverseMartrix(float[][] data) {
        float[][] newdata = new float[data.length][data[0].length];
        float A = getMartrixResult(data);
//      System.out.println(A);
        for(int i=0; i<data.length; i++) {
            for(int j=0; j<data[0].length; j++) {
                if((i+j)%2 == 0) {
                    newdata[i][j] = getMartrixResult(getConfactor(data, i+1, j+1)) / A;
                }else {
                    newdata[i][j] = -getMartrixResult(getConfactor(data, i+1, j+1)) / A;
                }

            }
        }
        newdata = trans(newdata);

        for(int i=0;i<newdata.length; i++) {
            for(int j=0; j<newdata[0].length; j++) {
                System.out.print(newdata[i][j]+ "   ");
            }
            System.out.println();
        }
        return newdata;
    }

    private float[][] trans(float[][] newdata) {
        // TODO Auto-generated method stub
        float[][] newdata2 = new float[newdata[0].length][newdata.length];
        for(int i=0; i<newdata.length; i++) 
            for(int j=0; j<newdata[0].length; j++) {
                newdata2[j][i] = newdata[i][j];
            }
        return newdata2;
    }

最后，我们通过测试代码来验证

public class ReverseMartrix {

    static float[][] data = {
        {1,2,-1 },  
        {3,1,0 },  
        {-1,-1,-2 },
    };

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ReverseMartrix rm = new ReverseMartrix();
        rm.getReverseMartrix(data);
    }
    …………………………
}