高斯消元法矩陣求逆代碼

自己隨便寫着玩的，時間復雜度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;
}