高斯消元法矩阵求逆代码

自己随便写着玩的，时间复杂度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;
}