高斯消元法矩阵求逆代码

自己随便写着玩的，时间复杂度O(n^3)，小矩阵使用没什么问题，大矩阵……还是用openCV或者其他的一些线性代数库吧

高斯消元法具体内容自己google吧

头文件

#ifndef inverse_matrix_h_

#define inverse_matrix_h_

#include<string.h>

void inverseMatrix(double** input,double**output,int dimension);

void swap(double** input,double**output,int dimension,int first_row,int second_row);

void reorderOutput(double** output,int dimension);

#endif  //inverse_matrix_h_

cpp文件

#include"inverse_matrix.h"

//高斯消元法求矩阵逆

void inverseMatrix(double** input,double**output,int dimension)

{

    int i,j,k;

    //将输出矩阵初始化为单位矩阵

    for(i=0;i<dimension;i++)

    {

        memset(output[i],0,sizeof(double)*dimension);

        output[i][i]=1;

    }

    for(i=0;i<dimension;++i)  //依次处理每一列

    {

        for(j=0;i<dimension;++j)  //如果当前行当前列值为0，做行变换

        {

            if(input[j][i]!=0)

            {

                swap(input,output,dimension,0,j);

                break;

            }

        }

        for(j=0;j<dimension;++j)  //依次处理每一行

        {

            if(j==0)  //如果是第一行，将input[j][i]设置为1，其他元素均除以input[i][i]

            {

                for(k=dimension-1;k>=0;--k)

                    output[j][k]/=input[j][i];

                for(k=dimension-1;k>=i;--k)

                    input[j][k]/=input[j][i];

            }

            else  //如果不是第一行，将每一行的input[j][i]设置为0，该行其他元素都要倍数的减去第一行对应位置上的值

            {

                for(k=dimension-1;k>=0;--k)

                    output[j][k]=output[j][k]-input[j][i]/input[0][i]*output[0][k];

                for(k=dimension-1;k>=i;--k)

                    input[j][k]=input[j][k]-input[j][i]/input[0][i]*input[0][k];

            }

        }

        swap(input,output,dimension,0,(i+1)%dimension);  //每次都将下一次需要处理的行和当前的第一行交换

    }

    reorderOutput(output,dimension); //因为之前的交换操作，行顺序乱了，需要重新排列一下，即把第一行的数据放到最后一行后面

}



void swap(double** input,double**output,int dimension,int first_row,int second_row)

{

    double* temp_row1=new double[dimension];

    double* temp_row2=new double[dimension];

    int i;

    for(i=0;i<dimension;i++)

    {

        temp_row1[i]=input[first_row][i];

        temp_row2[i]=output[first_row][i];

    }

    for(i=0;i<dimension;i++)

    {

        input[first_row][i]=input[second_row][i];

        output[first_row][i]=output[second_row][i];

        input[second_row][i]=temp_row1[i];

        output[second_row][i]=temp_row2[i];

    }



    delete[] temp_row1;

    delete[] temp_row2;

}



void reorderOutput(double** output,int dimension)

{

    double**temp=new double*[4];

    for(int i=0;i<4;++i)

        temp[i]=new double[4];



    for(int i=1;i<dimension;++i)

        memcpy(temp[i-1],output[i],sizeof(double)*dimension);

    memcpy(temp[dimension-1],output[0],sizeof(double)*dimension);



    for(int i=0;i<dimension;++i)

        memcpy(output[i],temp[i],sizeof(double)*dimension);



    for(int i=0;i<4;++i)

        delete[] temp[i];

    delete[] temp;

}

测试用的main函数

/*

高斯消元法矩阵求逆

*/

#include"inverse_matrix.h"

#include<stdio.h>

#include<windows.h>

#include <bitset>

#include<string>

#include<iostream>

using namespace std;



int main()

{

    int dimension=4;

    double matrix[4][4]={{1,1,1,1},{2,3,1,1},{3,-1,2,-1},{4,1,-3,2}};

    //double matrix[3][3]={{0,1,2},{1,1,4},{2,-1,0}};

    double**input=new double*[dimension];

    for(int i=0;i<dimension;++i)

    {

        input[i]=new double[dimension];

        for(int j=0;j<dimension;++j)

            input[i][j]=matrix[i][j];

    }

    double**output=new double*[dimension];

    for(int i=0;i<dimension;++i)

        output[i]=new double[dimension];



    inverseMatrix(input,output,dimension);



    for(int i=0;i<dimension;++i)

    {

        delete[] input[i];

        delete[] output[i];

    }

    delete[] input;

    delete[] output;

    system("pause");

    return 0;

}