C 矩阵：逆总是空的

矩阵的倒数总是0，我不明白为什么。谢谢你提前通知我。 4项建议： -主：用户输入矩阵，并显示结果（矩阵、行列式、LU分解和求逆）

#include<stdio.h>
#include<conio.h>
#include<math.h>

float determinant(float[20][20],float);
void cofactor(float[20][20],float);
void transpose(float[20][20],float[20][20],float);

void main() 
{
    float A[20][20]= {0},L[20][20]= {0}, U[20][20];
    float B[20]= {0}, X[20]= {0},Y[20]= {0};
    int i,j,k,n;
    printf("Enter the order of square matrix: ");
    scanf("%d",&n);
    printf("\nEntrer les elements de la matrice A:\n");
    for(i=0; i<n; i++)
    {
        for(j=0; j<n; j++)
        {
            printf("Entrer l'element A[%d][%d] : ", i,j);
            scanf("%f",&A[i][j]);
        }
    }
    printf("\nEntrer les termes de la matrice B\n");
    for(i=0; i<n; i++)
    {
        printf("B[%d]",i);
        scanf("%f",&B[i]);
    }
    for(j=0; j<n; j++)
    {
        for(i=0; i<n; i++)
        {
            if(i<=j)
            {
                U[i][j]=A[i][j];
                for(k=0; k<i-1; k++)
                    U[i][j]-=L[i][k]*U[k][j];
                if(i==j)
                    L[i][j]=1;
                else
                    L[i][j]=0;
            }
            else
            {
                L[i][j]=A[i][j];
                for(k=0; k<=j-1; k++)
                    L[i][j]-=L[i][k]*U[k][j];
                L[i][j]/=U[j][j];
                U[i][j]=0;
            }
        }
    }
    printf("[L]: \n");
    for(i=0; i<n; i++)
    {
        for(j=0; j<n; j++)
            printf("%9.3f",L[i][j]);
        printf("\n");
    }
    printf("\n\n[U]: \n");
    for(i=0; i<n; i++)
    {
        for(j=0; j<n; j++)
            printf("%9.3f",U[i][j]);
        printf("\n");
    }
   //Y pour calculer X
    for(i=0; i<n; i++)
    {
        Y[i]=B[i];
        for(j=0; j<i; j++)
        {
            Y[i]-=L[i][j]*Y[j];
        }
    }
    for(i=0; i<n; i++)
    {
        printf("%9.3f",Y[i]);
    }
    for(i=n-1; i>=0; i--)
    {
        X[i]= Y[i];
        for(j=i+1; j<n; j++)
        {
            X[i]-=U[i][j]*X[j];
        }
        X[i]/=U[i][i];
    }
    printf("\n\n[X]: \n");
    for(i=0; i<n; i++)
    {
        printf("%9.3f",X[i]);
    }
    printf("\n\nLe determinant de la matrice A est = %f",n);
  if (n==0)
   printf("\nCette matrice n'a pas d'inverse!\n");
  else {
   cofactor(A,k);
  }

getch();
}

float determinant(float a[20][20],float k)
{
  float s=1,det=0,b[20][20];
  int i,j,m,n,c;
  if (k==1)
    {
     return (a[0][0]);
    }
  else
    {
     det=0;
     for (c=0;c<k;c++)
       {
        m=0;
        n=0;
        for (i=0;i<k;i++)
          {
            for (j=0;j<k;j++)
              {
                b[i][j]=0;
                if (i != 0 && j != c)
                 {
                   b[m][n]=a[i][j];
                   if (n<(k-2))
                    n++;
                   else
                    {
                     n=0;
                     m++;
                     }
                   }
               }
             }
          det=det + s * (a[0][c] * determinant(b,k-1));
          s=-1 * s;
          }
    }

    return (det);
}

void cofactor(float num[20][20],float f) //fonction which will calculate the cofactof of matrix
{
 float b[20][20],fac[20][20];
 int p,q,m,n,i,j;
 for (q=0;q<f;q++)
 {
   for (p=0;p<f;p++)
    {
     m=0;
     n=0;
     for (i=0;i<f;i++)
     {
       for (j=0;j<f;j++)
        {
          if (i != q && j != p)
          {
            b[m][n]=num[i][j];
            if (n<(f-2))
             n++;
            else
             {
               n=0;
               m++;
               }
            }
        }
      }
      fac[q][p]=pow(-1,q + p) * determinant(b,f-1);
    }
  }
  transpose(num,fac,f);
}
/*Finding transpose of matrix*/
void transpose(float num[20][20],float fac[20][20],float r)
{
  int i,j;
  float b[20][20],inverse[20][20],n;

  for (i=0;i<r;i++)
    {
     for (j=0;j<r;j++)
       {
         b[i][j]=fac[j][i];
        }
    }
  n=determinant(num,r);
  for (i=0;i<r;i++)
    {
     for (j=0;j<r;j++)
       {
        inverse[i][j]=b[i][j] / n;
        }
    }
   printf("\n\n\nThe inverse of matrix is : \n");

   for (i=0;i<r;i++)
    {
     for (j=0;j<r;j++)
       {
         printf("\t%f",inverse[i][j]); //show inverse of the matrix
        }
    printf("\n");
     }
}

#包括
#包括
#包括
浮动行列式（浮动[20][20]，浮动）；
无效辅因子（float[20][20]，float）；
无效转置（float[20][20]，float[20][20]，float）；
void main（）
{
浮点数A[20][20]={0}，L[20][20]={0}，U[20][20]；
浮点B[20]={0}，X[20]={0}，Y[20]={0}；
int i，j，k，n；
printf（“输入方阵的顺序：”）；
scanf（“%d”和“&n”）；
printf（“\n矩阵元素A:\n”）；
对于（i=0；i，代码有几个问题，但主要错误是您向

cofactor(A,k);

这里，
k
是一个循环变量，其值与在执行三角分解的代码中使用后的值相同。（您可以看到该值为1，因为只打印了矩阵的一个条目。）

您应该使用矩阵的顺序，
n
：

cofactor(A, n);

一般来说，您应该使用更一致的命名法。在
main
中，矩阵的顺序是
n
，在
行列式中是
k
，在
辅因子中使用浮点变量
f
，在
转置中使用浮点变量
r
，以添加到在这里，
n
是一个表示行列式的浮点。我建议您使用整数
n
作为顺序，局部整数
I
，
j
和
k
作为循环变量–C99允许您仅为循环范围定义它们，例如
for（int I=0；…）
–浮点数的名称或多或少都有意义；
det
对于行列式是好的

进一步建议：


不要每次都写显式循环来打印矩阵；而是写一个函数来打印矩阵和一个函数来打印向量并调用它们
将计算与打印分开。例如，打印逆运算的代码不应是（名称不正确的？
transpose
）的一部分。相反，
transpose
应填写从
main
传入的矩阵，然后
main
应打印该矩阵
理想情况下，三角分解和方程求解也应该是函数。体验组织良好的代码的乐趣。
：）
您的代码有几个问题，但主要错误是您将错误的参数传递给了

cofactor(A,k);

这里，
k
是一个循环变量，其值与在执行三角分解的代码中使用后的值相同。（您可以看到该值为1，因为只打印了矩阵的一个条目。）

您应该使用矩阵的顺序，
n
：

cofactor(A, n);

一般来说，您应该使用更一致的命名法。在
main
中，矩阵的顺序是
n
，在
行列式中是
k
，在
辅因子中使用浮点变量
f
，在
转置中使用浮点变量
r
，以添加到在这里，
n
是一个表示行列式的浮点。我建议您使用整数
n
作为顺序，局部整数
I
，
j
和
k
作为循环变量–C99允许您仅为循环范围定义它们，例如
for（int I=0；…）
–浮点数的名称或多或少都有意义；
det
对于行列式是好的

进一步建议：


不要每次都写显式循环来打印矩阵；而是写一个函数来打印矩阵和一个函数来打印向量并调用它们
将计算与打印分开。例如，打印逆运算的代码不应是（名称不正确的？
transpose
）的一部分。相反，
transpose
应填写从
main
传入的矩阵，然后
main
应打印该矩阵
理想情况下，三角分解和方程求解也应该是函数。体验组织良好的代码的乐趣。
：）
注意：要查看更多的
float
值，请使用
printf（“%e”，一些浮点数）；
。发布示例输入、输出和预期输出会有所帮助。节省时间，请打开编译器警告：
printf（\n\nLe dela matrice A est=%f”，n）；
-->
..%d“，n）；
chux说了什么，但为什么浮点矩阵的行列式是整数？
n
是
transpose
中的行列式，而不是
main
中的行列式，您不需要打印它。（你也应该对矩阵的顺序使用一致的命名法，有时是
n
，有时是
k
，在
transpose
中，你甚至可以使用一个浮点，
r
表示顺序。）注意这个算法可能非常慢。你可以用高斯算法代替
O（n）
复杂性。注意：要查看更多的
浮点值，请使用
printf（“%e”，一些浮点数）；
。发布示例输入、输出和预期输出会有所帮助。节省时间，请打开编译器警告：
printf（“\n\nLe矩阵行列式A est=%f”，n）；
-->
..%d”，n）
chux说了什么，但是为什么浮点矩阵的行列式是整数？
n
是
transpose
中的行列式，而不是在
main
中，您需要打印它。（你也应该对矩阵的顺序使用一致的命名法，有时是
n
，有时是
k
，在
transpose
中，你甚至可以使用一个float，
r
来表示顺序。）注意，这个算法可能非常慢。你可以用高斯算法代替