矩阵求逆c语言

‘壹’ c语言 求矩阵的逆

//源程序如下#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<iostream.h>
#include<stdlib.h>
#include<math.h>
#define max 100void inputstyle(int *); //输入函数
void input(int **,int); //输入函数
long danx(int **,int);
int sgnx(int);
void martx(int **,int);int main(void)
{
int style=0,i=0;
int matrix[max][max],*p[max];
for(i=0;i<max;i++)*(p+i)=matrix[i]; //*(p+i)是指针，指向第i个字符串
char exit1=' ';
while(exit1!='E'&& exit1!='e'){ printf("求n阶矩阵的逆\n"); inputstyle(&style);
input(p,style);
printf("原矩阵为:\n");
for(i=0;i<style;i++){
for(int j=0;j<style;j++){
printf("%4d",matrix[i][j]);

}
printf("\n");
}

martx(p,style);
printf("\n");
printf("Exit=e Continue=Press any key\n");
cin>>exit1;
fflush(stdin);
printf("\n\n"); }
return(0);
} void input(int **p,int n){

for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
printf("输入矩阵(%d行,%d列)元素:",j+1,i+1);
*(*(p+j)+i)=0;
scanf("%d",*(p+j)+i);
fflush(stdin);
}
}
}void inputstyle(int *style){
do{
printf("输入矩阵n*n阶数n(0<n<%d):",max);
fflush(stdin);
scanf("%d",style);
fflush(stdin);
}while(*style<=0 && *style>max);

}long danx(int **p,int n){
int i=0,j1=0,k1=0,j2=0,k2=0;
long sum=0;
int operate[max][max],*po[max];
for(i=0;i<max;i++)*(po+i)=operate[i]; if(n==1)return *(*(p+0)+0);
else{
for(i=0;i<n;i++){
for(j1=1,j2=0;j1<n;j1++,j2++){
k1=-1;k2=-1;
while(k2<n-1){
k1++;
k2++;
if(k1==i)k1++;
*(*(po+j2)+k2)=*(*(p+j1)+k1);
}
}
/*for(int i1=0;i1<n-1;i1++){
for(int h1=0;h1<n-1;h1++){
printf("(%d,%d)%d ",i1,h1,*(*(po+h1)+i1));

}
printf("\n");
}*/

sum+=*(*(p+0)+i) * sgnx(1+i+1) * danx(po,n-1);
}
return sum;
}
}int sgnx(int i){
if(i%2==0)return(1);
else return(-1);
}void martx(int **p,int n){
int i=0,j=0,j1=0,k1=0,j2=0,k2=0,num=0;
int tramform[max][max];
int operate[max][max],*po[max];
for(i=0;i<max;i++)*(po+i)=operate[i];
num=danx(p,n);
if(num==0)printf("矩阵不可逆\n");
else{
if(n==1)printf("矩阵的逆为: 1/%d\n",num);
else{
printf("矩阵的逆为: 系数 1/%d *\n",num);
for(i=0;i<n;i++){
for(j=0;j<n;j++){
j1=-1;j2=-1;
while(j2<n-1){
j1++;j2++;
if(j1==j)j1++; k1=-1;k2=-1;
while(k2<n-1){
k1++;
k2++;
if(k1==i)k1++;
*(*(po+j2)+k2)=*(*(p+j1)+k1);
}
}

tramform[i][j]=sgnx(2+i+j) * danx(po,n-1);
}
}
for(i=0;i<n;i++){
for(j=0;j<n;j++){
printf("%4d",tramform[i][j]);
}
printf("\n");
}
}
}
}
//运行结果//希望对你有帮助

‘贰’ 用c语言怎么编写输入一个矩阵求其逆矩阵的程序

这是我编的一个简易矩阵计算器，C++语言，非常容易理解的，你可以参考求行列式和逆部分
#include <iostream>
#include <iomanip>
#include <conio.h>
#include "windows.h"
#include <string>
using namespace std;

void gotoxy(int x,int y) // 列x: 0~79 行y: 0~24
{ HANDLE hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
COORD coordScreen={x,y};
SetConsoleCursorPosition(hConsole,coordScreen);
return;
}
void setcolor(unsigned short ForeColor,unsigned short BackColor)
// 0--黑 1--暗蓝 2--暗绿 3--暗青 4--暗红 5--暗紫 6--蟹黄 7--暗白
// 8--灰 9--亮蓝 10-亮绿 11-亮青 12-亮红 13-亮紫 14-黄 15-亮白
{ HANDLE hCon = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hCon,(ForeColor % 16)|(BackColor % 16 * 16));
};

int main()
{
void plu();
void sub();
void amo();
void mul();
void ran();
void ord();
char sel='1';
while(sel != '0')
{ int i;
system("cls"); // 清屏
setcolor(15,0); // 下面显示黑底亮青字
gotoxy(8,1); cout<<"┌───────────────────────────┐";
for(i=2;i<20;i++)
{gotoxy(8,i);cout<<"│";gotoxy(64,i);cout<<"│";}
setcolor(15,6); // 下面显示红底白字
gotoxy(10,3); cout<<" ";
gotoxy(10,4); cout<<" 简 易 矩 阵 计 算 器 ";
gotoxy(10,5); cout<<" ";
setcolor(15,0); // 下面显示黑底亮青字
gotoxy(10,7); cout<<" 1 ---- 矩阵加法 2 ---- 矩阵减法 ";
gotoxy(10,9); cout<<" 3 ---- 矩阵数乘 4 ---- 矩阵乘法 ";
gotoxy(10,11); cout<<" 5 ---- 矩阵行列式 6 ---- 矩阵的逆 ";
gotoxy(10,13); cout<<" 0 ---- 退出 ";
gotoxy(10,15); cout<<" 请选择(0--6):";
gotoxy(8,20); cout<<"└───────────────────────────┘";
do
{ gotoxy(28,15); sel=getche( );}
while ( sel!='1' && sel!='2' && sel!='3' && sel!='4' && sel!='5' && sel!='6'&& sel!='0');

switch(sel)
{
case '1':plu(); break;
case '2':sub(); break;
case '3':amo(); break;
case '4':mul(); break;
case '5':ran(); break;
case '6':ord(); break;
case '0': break;
}
}
system("cls");
gotoxy(25,10);
cout<<"谢 谢 使 用 系 统 ！"<<endl;
return 0;
}

void plu()//加法
{ char l;
system("cls"); // 清屏
setcolor(14,0); // 下面用黑底黄字
int a,b,i,j;
gotoxy(0,0);cout<<">>>>>> 矩阵加法 ";
gotoxy(0,2);cout<<"请输入矩阵的行数：";
cin>>a;
cout<<endl;
cout<<"请输入矩阵的列数：";
cin>>b;
cout<<endl;
double m[10][10],n[10][10];
cout<<"请输入第一个矩阵："<<endl;
for(i=0;i<a;i++)
for(j=0;j<b;j++)
{gotoxy(6*j+20,2*i+6); cin>>m[i][j];}
cout<<endl<<endl<<"请输入第二个矩阵："<<endl;
for(i=0;i<a;i++)
for(j=0;j<b;j++)
{gotoxy(6*j+20,2*a+2*i+7);cin>>n[i][j];}
cout<<endl<<">>>>>>>"<<endl<<"矩阵加法结果为：";
for(i=0;i<a;i++)
for(j=0;j<b;j++)
{gotoxy(6*j+20,4*a+2*i+8);cout<<m[i][j]+n[i][j];}
gotoxy(0,6*a+9);
cout<<">>>>>>>>按任意键退出:";
l=getche();

}

void sub()//减法
{ char l;
system("cls"); // 清屏
setcolor(14,0); // 下面用黑底黄字
int a,b,i,j;
gotoxy(0,0);cout<<">>>>>矩阵减法";
gotoxy(0,2);cout<<"请输入矩阵的行数：";
cin>>a;
cout<<endl;
cout<<"请输入矩阵的列数：";
cin>>b;
cout<<endl;
double m[10][10],n[10][10];
cout<<"请输入第一个矩阵："<<endl;
for(i=0;i<a;i++)
for(j=0;j<b;j++)
{gotoxy(6*j+20,2*i+6); cin>>m[i][j];}
cout<<endl<<endl<<"请输入第二个矩阵："<<endl;
for(i=0;i<a;i++)
for(j=0;j<b;j++)
{gotoxy(6*j+20,2*a+2*i+7);cin>>n[i][j];}
cout<<endl<<">>>>>>>"<<endl<<"矩阵减法结果为：";
for(i=0;i<a;i++)
for(j=0;j<b;j++)
{gotoxy(6*j+20,4*a+2*i+8);cout<<m[i][j]-n[i][j];}
gotoxy(0,6*a+9);
cout<<">>>>>>>>按任意键退出:";
l=getche();

}

void amo()//数乘
{ char h;
system("cls"); // 清屏
setcolor(14,0); // 下面用黑底黄字
int a,b,i,j;
gotoxy(0,0);cout<<">>>>>>矩阵数乘";
gotoxy(0,2);cout<<"请输入矩阵的行数：";
cin>>a;
cout<<endl;
cout<<"请输入矩阵的列数：";
cin>>b;
cout<<endl;
double m[10][10],c;
cout<<"请输入矩阵："<<endl;
for(i=0;i<a;i++)
for(j=0;j<b;j++)
{gotoxy(6*j+20,2*i+6);cin>>m[i][j];}
cout<<endl<<"请输入与矩阵相乘的实数：";
cin>>c;
cout<<endl<<endl<<"矩阵数乘结果为：";
for(i=0;i<a;i++)
for(j=0;j<b;j++)
{gotoxy(8*j+20,2*a+2*i+9);cout<<m[i][j]*c;}
gotoxy(0,4*a+12);
cout<<">>>>>>>按任意键退出：";h=getche();
}

void mul()//乘法
{
char k;
system("cls"); // 清屏
setcolor(14,0); // 下面用黑底黄字
int a,b,c,i,j,q;
gotoxy(0,0);cout<<">>>>>>矩阵乘法";
gotoxy(0,2);cout<<"请输入第一个矩阵的行数：";
cin>>a;
cout<<endl<<"请输入第一个矩阵的列数：";
cin>>b;
cout<<endl<<"则第二个矩阵的行数也为:"<<b;
cout<<endl<<endl<<"请输入第二个矩阵的列数：";
cin>>c;
cout<<endl;
double m[10][10],n[10][10],p[10][10]={0};
cout<<"请输入第一个矩阵："<<endl;
for(i=0;i<a;i++)
for(j=0;j<b;j++)
{gotoxy(6*j+18,2*i+10); cin>>m[i][j];}
cout<<endl<<endl<<"请输入第二个矩阵：";
for(i=0;i<b;i++)
for(j=0;j<c;j++)
{gotoxy(6*j+18,2*a+2*i+11);cin>>n[i][j];}
cout<<endl<<">>>>>>>"<<endl<<"矩阵相乘结果为： ";
for(i=0;i<a;i++)
for(j=0;j<c;j++)
for(q=0;q<b;q++) p[i][j]=p[i][j]+m[i][q]*n[q][j];
for(i=0;i<a;i++)
for(j=0;j<c;j++)
{gotoxy(10*j+18,2*a+2*b+2*i+12);cout<<p[i][j];}
gotoxy(16,2*a+2*b+2*i+15);
cout<<">>>>>>>按任意键退出：";k=getche();

}
//===================================================行列式

float Fun(int n1,float a1[10][10]);
void ran()
{
system("cls"); // 清屏
setcolor(15,0); // 下面用黑底黄字
char k;
int n,i,j;
cout<<">>>>>矩阵行列式"<<endl<<endl<<"请输入矩阵阶数: ";
cin>>n;
cout<<endl<<"请输入矩阵:"<<endl;
float a[10][10];
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{gotoxy(6*j+12,2*i+4);cin>>a[i][j];}
cout<<endl<<"行列式为: "<<Fun(n,a)<<endl<<endl;
cout<<">>>>>>按任意键退出：";
k=getche();

}
float Fun(int n1,float a1[10][10])//求行列式的递归函数
{
int i_1,j_1,c;//c为数组b的行
float b[10][10];
int p=0,q=0;
float sum=0;
if(n1==1) return a1[0][0];
for(i_1=0;i_1<n1;i_1++)
{
for(c=0;c<n1-1;c++)
{if(c<i_1) p=0;
else p=1;
for(j_1=0;j_1<n1-1;j_1++)
{b[c][j_1]=a1[c+p][j_1+1];}
}
if(i_1%2==0)
q=1;
else q=(-1);
sum=sum+a1[i_1][0]*q*Fun(n1-1,b);
}return sum;
}

//================================================================

void ord()
{
char g;
system("cls"); // 清屏
setcolor(15,0); // 下面用黑底黄字
int i,j,n;
gotoxy(0,0);cout<<">>>>>矩阵的逆";
gotoxy(0,2);cout<<"请输入矩阵的阶数：";
cin>>n;
cout<<endl;
cout<<"请输入矩阵：";
float l[10][10],m[10][10],p;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{gotoxy(4*j+12,2*i+4); cin>>l[i][j];}
if(Fun(n,l)==0) cout<<endl<<"该矩阵无逆！！！"<<endl;
else
{p=Fun(n,l);
cout<<endl<<"矩阵的逆为： ";
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{{float f[10][10];
int r,w,e,d;//e为数组f的行数
for(int j_1=0,e=0;j_1<n-1,e<n-1;j_1++,e++)
for(int i_1=0,d=0;i_1<n-1,d<n-1;i_1++,d++)
{if(e<i) r=0;else r=1;
if(d<j) w=0;else w=1;
f[i_1][j_1]=l[i_1+w][j_1+r];};
if((i+j)%2==0) m[i][j]=Fun(n-1,f)/p;
else m[i][j]=-Fun(n-1,f)/p;
};
gotoxy(9*j+12,2*n+2*i+4);cout<<m[i][j];};};
cout<<endl<<endl<<">>>>>>按任意键退出：";g=getche();
}

‘叁’ c语言编程求任意对称正定矩阵的逆。

#ifndef __MATRIX_DOT_H__
#define __MATRIX_DOT_H__

template <class T>
void Swap(T& a, T& b)
{
T temp;

temp = a;
a = b;
b = temp;
}

class CMatrix
{
static double ZERO;//极小值
public:
CMatrix(int row = 3, int col = 3); //
CMatrix(const CMatrix& right); //拷贝构造函数
~CMatrix();
void Show(const char* pre = NULL)const; //输出矩阵
void Free();
int Resize(int row, int col); //重新定义矩阵大小
int GetRow()const{ return m_iRow; } //返回矩阵行数
int GetCol()const{ return m_iCol; } //返回矩阵列数
int RowSwap(int x, int y); //行交换,成功返回1，否则0
int ColSwap(int x, int y); //列交换
static void SetZero(double z); //设定ZERO的值,所有CMatrix实例精度都将改变

const CMatrix Transpose()const; //返回转置矩阵
const CMatrix Adjoint()const; //伴随矩阵
const CMatrix Resie(int row, int col)const;//求对应元素的余子式
const CMatrix Contrary()const;//逆矩阵
const CMatrix Gauss_Jordan(double* pDet = NULL)const;//逆矩阵(高斯-约旦法),pDet为行列式,
//此法精度较低,但效率较高
double Resie_a(int row, int col)const;//求对应元素的代数余子式
double Determinant()const; //返回方阵的行列式
double Det_Recursion()const; //返回方阵的行列式(递归)

int IsZero()const; //判断元素是否全为0(零矩阵)
int IsPhalanx()const; //判断是否为方阵
int IsReverse()const; //判断矩阵是否可逆
int IsNonfunnyPhalanx()const; //判断是否非奇异方阵

double* operator[](int i)const; //操作单个元素
CMatrix& operator=(const CMatrix& right);
CMatrix& operator=(const double* pRight);
CMatrix& operator=(const double** ppRight);
const CMatrix& operator+()const; //一元操作符
const CMatrix operator-()const; //一元操作符
const CMatrix operator+(const CMatrix& right)const;
const CMatrix operator-(const CMatrix& right)const;
const CMatrix operator*(const CMatrix& right)const;
const CMatrix operator*(const double& right)const;
const CMatrix operator/(const double& right)const;
CMatrix& operator+=(const CMatrix& right);
CMatrix& operator-=(const CMatrix& right);
CMatrix& operator*=(const CMatrix& right);
CMatrix& operator*=(const double& right);
CMatrix& operator/=(const double& right);
int operator==(const CMatrix& right)const;
int operator!=(const CMatrix& right)const;

private:
int m_iRow; //行数
int m_iCol; //列数
double** m_ppData; //数据
};

#endif //__MATRIX_DOT_H__

//matrix.cpp
//

#include <windows.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <assert.h>
#include "matrix.h"

double CMatrix::ZERO = 1e-10;

CMatrix::CMatrix(int row/*=3*/, int col/*=3*/)
{
m_ppData = NULL;
Resize(row, col);
}

//拷贝构造函数
CMatrix::CMatrix(const CMatrix& right)
{
m_ppData = NULL;//一定要加这句初始化(一个对象不会同时调用构造函数和拷贝构造函数)

Resize(right.GetRow(), right.GetCol());
for(int i = 0; i < right.GetRow(); i++)
{
for(int j = 0; j < right.GetCol(); j++)
m_ppData[i][j] = right[i][j];
}
}

CMatrix::~CMatrix()
{
Free();
}

void CMatrix::Free()
{
if(m_ppData != NULL){
for(int i = 0; i < m_iRow; i++)
{
if(m_ppData[i] != NULL)
delete[] m_ppData[i];
m_ppData[i] = NULL;
}
m_ppData = NULL;
}
}

int CMatrix::Resize(int row, int col)
{
assert(row > 0 && col > 0);

//释放空间
Free();

//申请空间
m_iRow = row;
m_iCol = col;
m_ppData = new double*[m_iRow];
assert(m_ppData != NULL);
for(int i = 0; i < m_iRow; i++)
{
m_ppData[i] = new double[m_iCol];
assert(m_ppData[i] != NULL);
}

//初始化
for(i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
m_ppData[i][j] = 0;
}
return 1;
}

//zero
void CMatrix::SetZero(double z)
{
double zero = fabs(z);
if(zero > 1.0f) return;

ZERO = zero;
}

//show
void CMatrix::Show(const char* pre/*=NULL*/)const
{
int i, j;
#ifdef _WINDOWS
if(m_iRow > 10 || m_iCol > 10)
MessageBox(NULL, "矩阵数据量太大，不能输出", "警告", MB_OK);

char buf[4096];
char temp[256];

strcpy(buf, "");
if(pre != NULL)
{
strcpy(buf, pre);
strcat(buf, "\n");
}

for(i = 0; i < m_iRow; i++)
{
for(j = 0; j < m_iCol; j++)
{
sprintf(temp, "%.3f\t", m_ppData[i][j]);
strcat(buf, temp);
}
strcat(buf, "\n");
}
MessageBox(NULL, buf, "提示信息", MB_OK);
#else
if(pre != NULL)
puts(pre);
for(i = 0; i < m_iRow; i++)
{
for(j = 0; j < m_iCol; j++)
printf("%f\t", m_ppData[i][j]);
printf("\n");
}
#endif //_WINDOWS
}

///////////////////////////////////////计算//////////////////////////////////////

//行交换
int CMatrix::RowSwap(int x, int y)
{
if(x < 0 || x >= m_iRow || y < 0 || y >= m_iRow)
return 0;
if(x == y)
return 1;
for(int i = 0; i < m_iCol; i++)
{
Swap(m_ppData[x][i], m_ppData[y][i]);
}
return 1;
}

//列交换
int CMatrix::ColSwap(int x, int y)
{
if(x < 0 || x >= m_iCol || y < 0 || y >= m_iCol)
return 0;
if(x == y)
return 1;
for(int i = 0; i < m_iRow; i++)
{
Swap(m_ppData[i][x], m_ppData[i][y]);
}
return 1;
}

//转置
const CMatrix CMatrix::Transpose()const
{
CMatrix tr(m_iCol, m_iRow);

for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
tr[j][i] = m_ppData[i][j];
}
return tr;
}

//计算方阵的行列式(精度不高)
double CMatrix::Determinant()const
{
assert(m_iRow == m_iCol);

CMatrix temp = *this;
int i,j,m,n,s,t,k=1;
double f=1,c,x,sn;

for (i=0,j=0; i<m_iRow&&j<m_iRow; i++,j++)
{
if (temp[i][j]==0)
{
for (m = i;m < m_iRow; m++)
{
if(fabs(temp[m][j]) > ZERO)//0
break;
}

if (m == m_iRow)
{
return 0;
}
else
for (n = j; n < m_iRow; n++)
{
c = temp[i][n];
temp[i][n] = temp[m][n];
temp[m][n] = c;
}
k *= (-1);
}
for (s = m_iRow-1; s>i; s--)
{
x = temp[s][j];
for (t = j; t < m_iRow; t++)
temp[s][t] -= temp[i][t] * (x/temp[i][j]);
}
}
for (i = 0; i < m_iRow; i++)
f *= temp[i][i];
sn = k * f;

return sn;
}

//行列式(递归，精度较高)
double CMatrix::Det_Recursion()const
{
assert(m_iRow == m_iCol);

CMatrix temp;
double ans = 0;

if(m_iRow == 1)
{
return m_ppData[0][0];
}
else if(m_iRow == 2)
{
return m_ppData[0][0]*m_ppData[1][1] - m_ppData[1][0]*m_ppData[0][1];
}
else
{
for(int i = 0; i < m_iRow; i++)
{
temp = Resie(i, 0);//this->Resie(i, 0)
ans += temp.Det_Recursion()*m_ppData[i][0]*pow(-1, i);
}
}

return ans;
}

//计算方阵的余子式
const CMatrix CMatrix::Resie(int row, int col)const
{
CMatrix re;
int index = 0;

assert(m_iRow == m_iCol);
assert(m_iRow >= 2);
assert(row < m_iRow && col < m_iCol);
assert(row >= 0 && col >= 0);
double* pData = NULL;
pData = new double[(m_iRow-1)*(m_iCol-1)];
assert(pData != NULL);
re.Resize(m_iRow-1, m_iCol-1);

for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
if(i != row && j != col)
pData[index++] = m_ppData[i][j];
}
re = pData;

delete[] pData;
pData = NULL;
return re;
}

//计算方阵的代数余子式
double CMatrix::Resie_a(int row, int col)const
{
return (Resie(row, col)).Det_Recursion()*pow(-1, row+col);
}

//伴随矩阵
const CMatrix CMatrix::Adjoint()const
{
CMatrix ad(m_iRow, m_iCol);

for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
ad[j][i] = Resie_a(i, j);
}
return ad;
}

//逆矩阵
const CMatrix CMatrix::Contrary()const
{
assert(IsReverse());

CMatrix co(m_iRow, m_iCol);
co = Adjoint();//this
co /= Det_Recursion();//this

return co;
}

//高斯-约旦法求逆矩阵(全选主元), pDet为原方阵的行列式
const CMatrix CMatrix::Gauss_Jordan(double* pDet/*=NULL*/)const
{
assert(IsReverse());

double fDet = 1.0f;
int flag = 1;
int k = 0, i = 0, j = 0;
CMatrix out(m_iRow, m_iCol);//逆
CMatrix m = *this;//原
CMatrix rhs(2, m_iRow);//保存主元素位置,0 i, 1 j;

for(k = 0; k < m_iRow; k++)
{
//第一步：全选主元
double fMax = 0.0f;
for(i = 0; i < m_iRow; i++)
{
for(j = 0; j < m_iCol; j++)
{
const double f = fabs(m[i][j]);
if(f > fMax)
{
fMax = f;
rhs[0][k] = i;
rhs[1][k] = j;
}
}
}
//if(fMax < 0.00001)//元素全为0
//{
// fDet = 0.0f;
// return out;
//}
if((int)rhs[0][k] != k)
{
flag = -flag;
m.RowSwap((int)rhs[0][k], k);
}
if((int)rhs[1][k] != k)
{
flag = -flag;
m.ColSwap((int)rhs[1][k], k);
}

//计算行列值
fDet *= m[k][k];

//计算逆矩阵
//第二步
m[k][k] = 1.0f/m[k][k];

//第三步
for(j = 0; j < m_iCol; j++)
{
if(j != k)
m[k][j] *= m[k][k];
}

//第四步
for(i = 0; i < m_iRow; i++)
{
if(i != k)
{
for(j = 0; j < m_iCol; j++)
{
if(j != k)
m[i][j] = m[i][j] - m[i][k]*m[k][j];
}
}
}

//第五步
for(i = 0; i < m_iRow; i++)
{
if(i != k)
{
m[i][k] *= -m[k][k];
}
}
}//end for(k);

for(k = m_iRow-1; k >= 0; k--)
{
if((int)rhs[1][k] != k)
{
m.RowSwap((int)rhs[1][k], k);
}
if((int)rhs[0][k] != k)
{
m.ColSwap((int)rhs[0][k], k);
}
}

fDet *= flag;
if(pDet != NULL)
*pDet = fDet;

return m;
}

///////////////////////////////////////判断//////////////////////////////////////

//零矩阵
int CMatrix::IsZero()const
{
for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
if(fabs(m_ppData[i][j]) > ZERO)
return 0;
}
return 1;
}

//方阵
int CMatrix::IsPhalanx()const
{
return (m_iRow == m_iCol);
}

//非奇异方阵
int CMatrix::IsNonfunnyPhalanx()const
{
return (IsPhalanx() && fabs(Det_Recursion()) > ZERO);
}

//可逆矩阵
int CMatrix::IsReverse()const
{
return IsNonfunnyPhalanx();
}

///////////////////////////////////////操作符重载//////////////////////////////////////

// []
double* CMatrix::operator [](int i)const
{
assert(i >= 0 && i < m_iRow);

return m_ppData[i];
}

// =
CMatrix& CMatrix::operator =(const CMatrix& right)
{
if(this == &right) return *this;

if((m_iRow != right.GetRow())
|| (m_iCol != right.GetCol()))// 添加于 2005-11-09
{
Resize(right.GetRow(), right.GetCol());
}
for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
m_ppData[i][j] = right[i][j];
}

return *this;
}

// =
CMatrix& CMatrix::operator =(const double* pRight)
{
assert(pRight != NULL);
for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
m_ppData[i][j] = pRight[m_iCol*i + j];
}
return *this;
}

// =
CMatrix& CMatrix::operator =(const double** ppRight)
{
assert(ppRight != NULL);
for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
m_ppData[i][j] = ppRight[i][j];
}
return *this;
}

// 一元操作符+
const CMatrix& CMatrix::operator +()const
{
return *this;
}

// 一元操作符-
const CMatrix CMatrix::operator -()const
{
CMatrix temp(m_iRow, m_iCol);

for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
temp[i][j] = -m_ppData[i][j];
}
return temp;
}

// +
const CMatrix CMatrix::operator +(const CMatrix& right)const
{
CMatrix temp(m_iRow, m_iCol);

if(m_iRow == right.GetRow()
&& m_iCol == right.GetCol())
{
for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
temp[i][j] = m_ppData[i][j] + right[i][j];
}
}
return temp;
}

// -
const CMatrix CMatrix::operator -(const CMatrix& right)const
{
CMatrix m_temp(m_iRow, m_iCol);

if(m_iRow == right.GetRow()
&& m_iCol == right.GetCol())
{
for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
m_temp[i][j] = m_ppData[i][j] - right[i][j];
}
}
return m_temp;
}

// *
const CMatrix CMatrix::operator *(const CMatrix& right)const
{
double temp = 0;

CMatrix m_temp(m_iRow, right.GetCol());

if(m_iCol != right.GetRow())
return m_temp;

for(int i = 0; i < m_temp.GetRow(); i++)
{
for(int j = 0; j < m_temp.GetCol(); j++)
{
temp = 0;
for(int k = 0; k < right.GetRow(); k++)
temp += m_ppData[i][k] * right[k][j];
m_temp[i][j] = temp;
}
}
return m_temp;
}

// *
const CMatrix CMatrix::operator *(const double& right)const
{
CMatrix m_temp(m_iRow, m_iCol);

for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
m_temp[i][j] = m_ppData[i][j] * right;
}
return m_temp;
}

// /
const CMatrix CMatrix::operator /(const double& right)const
{
CMatrix m_temp(m_iRow, m_iCol);

for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
m_temp[i][j] = m_ppData[i][j] / right;
}
return m_temp;
}

// +=
CMatrix& CMatrix::operator +=(const CMatrix& right)
{
*this = (*this) + right;
return *this;
}

// -=
CMatrix& CMatrix::operator -=(const CMatrix& right)
{
*this = (*this) - right;
return *this;
}

// *=
CMatrix& CMatrix::operator *=(const CMatrix& right)
{
*this = (*this) * right;
return *this;
}

// *=
CMatrix& CMatrix::operator *=(const double& right)
{
*this = (*this) * right;
return *this;
}

// /=
CMatrix& CMatrix::operator /=(const double& right)
{
*this = (*this) / right;
return *this;
}

// ==
int CMatrix::operator ==(const CMatrix& right)const
{
if(this == &right) return 1;

if((m_iRow != right.GetRow())
|| (m_iCol != right.GetCol()))
{
return 0;
}

for(int i = 0; i < m_iRow; i++)
{
for(int j = 0; j < m_iCol; j++)
if(fabs(m_ppData[i][j] - right[i][j]) > ZERO)//0
return 0;
}

return 1;
}

// !=
int CMatrix::operator !=(const CMatrix& right)const
{
return !(*this == right);
}

‘肆’ C璇瑷鐢ㄤ簩缁存暟缁勫疄鐜扮烦阒垫眰阃

鎴戜互鍓嶅啓杩囨眰阃嗙烦阒电殑绋嫔簭銆备笉杩囨病链夌敤鍒扮粨鏋勪綋锛屼綘鐪嬬湅濡备綍銆
#include<stdio.h>
void main()
{
int N;
printf("杈揿叆涓嶈秴杩10镄勭烦阒电殑阒舵暟N:\n");
scanf("%d",&N);
float a[10][10],b[10][20],c[10][10],t;
int i,j,m;
printf("璇疯緭鍏ヨ屽垪寮忎笉涓0镄勭烦阒础(%d阒):\n",N); //鐭╅樀A镄勫悇鍏幂礌瀛桦叆浜岀淮鏁扮粍a涓銆
for(i=0;i<N;i++)
for(j=0;j<N;j++)
scanf("%f",&a[i][j]);
//澧炲箍鐭╅樀锛圆|E锛夊瓨鍏ヤ簩缁存暟缁刡涓
for(i=0;i<N;i++)
for(j=0;j<N;j++)
b[i][j]=a[i][j];

for(i=0;i<N;i++)
for(j=N;j<2*N;j++)
b[i][j]=0;

for(i=0;i<N;i++)
b[i][N+i]=1;

for(m=0;m<N;m++) //瀵规疮琛岃繘琛屽勭悊銆
{
t=b[m][m]; //棰勫瓨b[m][m]銆
i=m;
while(b[m][m]==0)
{
b[m][m]=b[i+1][m];
i++;
}

if(i>m)
{
b[i][m]=t; //瀹炵幇浜ゆ崲銆

//浜ゆ崲鍏跺畠钖勫垪鐩稿簲浣岖疆镄勫厓绱
for(j=0;j<m;j++)
{
t=b[m][j];
b[m][j]=b[i][j];
b[i][j]=t;
}
for(j=m+1;j<2*N;j++)
{
t=b[m][j];
b[m][j]=b[i][j];
b[i][j]=t;
}

}

for(i=m+1;i<N;i++)
for(j=2*N-1;j>=m;j--)
b[i][j]-=b[i][m]*b[m][j]/b[m][m]; //m=0镞讹纴灏嗙涓琛岀殑-b[i][0]/b[0][0]鍊嶅姞鍒颁互涓嫔悇琛屻傝繖镙蜂互涓嬫疮琛岀涓涓鍏幂礌b[i][0]灏变负0銆

for(j=2*N-1;j>=m;j--)
b[m][j]/=b[m][m]; //瀵圭珐琛屼綔琛屽彉鎹锛屽悓闄や互b[m][m]锛屼娇b[m][m]涓1銆

}

printf("绗涓姝ュ彉鎹㈠悗寰楀埌镄勫炲箍鐭╅樀涓猴细\n");
for(i=0;i<N;i++)
{
for(j=0;j<2*N;j++)
printf("%3.5f ",b[i][j]);
printf("\n"); //瀹炵幇浜嗭细姣忎釜i瀵瑰簲涓涓鎹㈣屻
}

m=N-1;
while(m>0)
{
for(i=0;i<m;i++)
for(j=2*N-1;j>=m;j--) //鍗冧竾娉ㄦ剰锛屾ゅ刯蹇呴’阃掑噺锛屽惁鍒檅[i][m]鍏埚彉涓0锛屽悗闱㈢殑璁＄畻灏辨棤鏁堬紒
b[i][j]-=b[i][m]*b[m][j];
m--;
}

printf("链钖庡缑鍒扮殑澧炲箍鐭╅樀涓猴细\n");
for(i=0;i<N;i++)
{
for(j=0;j<2*N;j++)
printf("%3.5f ",b[i][j]);
printf("\n"); //瀹炵幇浜嗭细姣忎釜i瀵瑰簲涓涓鎹㈣屻
}

for(i=0;i<N;i++) //灏嗛嗙烦阒靛瓨鍏ヤ簩缁存暟缁刢涓銆
for(j=0;j<N;j++)
c[i][j]=b[i][N+j];

printf("鏁呴嗙烦阒典负锛\n");

for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
printf("%3.5f ",c[i][j]);
printf("\n"); //瀹炵幇浜嗭细姣忎釜i瀵瑰簲涓涓鎹㈣屻
}

}

‘伍’ c语言编写一个子函数求矩阵的逆矩阵

#include<stdio.h>
#define N 10
int getA(int arcs[N][N],int n)//按第一行展开计算|A|
{
if(n==1)
{
return arcs[0][0];
}
int ans = 0;
int temp[N][N];
int i,j,k;
for(i=0;i<n;i++)
{
for(j=0;j<n-1;j++)
{
for(k=0;k<n-1;k++)
{
temp[j][k] = arcs[j+1][(k>=i)?k+1:k];

}
}
int t = getA(temp,n-1);
if(i%2==0)
{
ans += arcs[0][i]*t;
}
else
{
ans -= arcs[0][i]*t;
}
}
return ans;
}
void getAStart(int arcs[N][N],int n,int ans[N][N])//计算每一行每一列的每个元素所对应的余子式，组成A*
{
if(n==1)
{
ans[0][0] = 1;
return;
}
int i,j,k,t;
int temp[N][N];
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
for(k=0;k<n-1;k++)
{
for(t=0;t<n-1;t++)
{
temp[k][t] = arcs[k>=i?k+1:k][t>=j?t+1:t];
}
}

ans[j][i] = getA(temp,n-1);
if((i+j)%2 == 1)
{
ans[j][i] = - ans[j][i];
}
}
}
}

int main()
{
int arcs[N][N];
int astar[N][N];
int i,j;
int n;
while(scanf("%d",&n)!=EOF && n)
{
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&arcs[i][j]);
}
}

int a = getA(arcs,n);
if(a==0)
{
printf("can not transform!\n");
}
else
{
getAStart(arcs,n,astar);
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("%.3lf ",(double)astar[i][j]/a);
}
printf("\n");
}
}
printf("\n");

}

return 0;
}

‘陆’ C语言编程：编写一个函数求逆矩阵

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

voidMatrixOpp(double*A,intm,intn,double*invmat);
voidMatrixInver(double*A,intm,intn,double*invmat);
doubleSurplus(doubleA[],intm,intn);
intmatrix_inv(double*p,intnum,double*invmat);

voidMatrixOpp(doubleA[],intm,intn,double*invmat)
{
	inti,j,x,y,k;
	double*SP=NULL,*AB=NULL,*B=NULL,X;
	SP=(double*)malloc(m*n*sizeof(double));
	AB=(double*)malloc(m*n*sizeof(double));
	B=(double*)malloc(m*n*sizeof(double));
	X=Surplus(A,m,n);
	X=1/X;

	for(i=0;i<m;i++)
		for(j=0;j<n;j++)
		{
			for(k=0;k<m*n;k++)
				B[k]=A[k];
			{
				for(x=0;x<n;x++)
					B[i*n+x]=0;
				for(y=0;y<m;y++)
					B[m*y+j]=0;
				B[i*n+j]=1;
				SP[i*n+j]=Surplus(B,m,n);
				AB[i*n+j]=X*SP[i*n+j];
			}
		}
	MatrixInver(AB,m,n,invmat);
	free(SP);
	free(AB);
	free(B);
}

voidMatrixInver(doubleA[],intm,intn,double*invmat)
{
	inti,j;
	double*B=invmat;

	for(i=0;i<n;i++)
		for(j=0;j<m;j++)
			B[i*m+j]=A[j*n+i];
}

doubleSurplus(doubleA[],intm,intn)
{
	inti,j,k,p,r;
	doubleX,temp=1,temp1=1,s=0,s1=0;
	if(n==2)
	{
		for(i=0;i<m;i++)
			for(j=0;j<n;j++)
				if((i+j)%2)
					temp1*=A[i*n+j];
				else
					temp*=A[i*n+j];
		X=temp-temp1;
	}
	else
	{
		for(k=0;k<n;k++)
		{
			for(i=0,j=k;i<m,j<n;i++,j++)
				temp*=A[i*n+j];
			if(m-i)
			{
				for(p=m-i,r=m-1;p>0;p--,r--)
					temp*=A[r*n+p-1];
			}
			s+=temp;
			temp=1;
		}

		for(k=n-1;k>=0;k--)
		{
			for(i=0,j=k;i<m,j>=0;i++,j--)
				temp1*=A[i*n+j];
			if(m-i)
			{
				for(p=m-1,r=i;r<m;p--,r++)
					temp1*=A[r*n+p];
			}
			s1+=temp1;
			temp1=1;
		}
		X=s-s1;
	}
	returnX;
}

intmatrix_inv(double*p,intnum,double*invmat)
{
	if(p==NULL||invmat==NULL)
	{
		return1;
	}
	if(num>10)
	{
		return2;
	}
	MatrixOpp(p,num,num,invmat);
	return0;
}

intmain()
{
	inti,j;
	intnum;
	double*arr=NULL;
	double*result=NULL;
	intflag;

	printf("请输入矩阵维数：
");
	scanf("%d",&num);
	arr=(double*)malloc(sizeof(double)*num*num);
	result=(double*)malloc(sizeof(double)*num*num);
	
	printf("请输入%d*%d矩阵：
",num,num);
	for(i=0;i<num;i++)
	{
		for(j=0;j<num;j++)
		{
			scanf("%lf",&arr[i*num+j]);
		}
	}

	flag=matrix_inv(arr,num,result);

	if(flag==0)
	{
		printf("逆矩阵为：
");
		for(i=0;i<num*num;i++)
		{
			printf("%lf	",*(result+i));
			if(i%num==(num-1))
				printf("
");
		}
	}
	elseif(flag==1)
	{
		printf("p/q为空
");
	}
	else
	{
		printf("超过最大维数
");
	}

	system("PAUSE");
	free(arr);
	free(result);
	return0;
}