一个计算NxN矩阵行列式的C程序

Question

我正在尝试编写一个可以为我计算行列式的程序，这是我迄今为止所做的。但它不起作用，对于我提供的每个矩阵都只打印出6356918。我甚至将我的代码与互联网上的一些其他代码进行了比较，但那并没有起作用。

而且我不知道指针的任何内容，因此无法使用它们。我尝试调试，但我对它也不太了解，但第二个函数中的第一个“if”和计算行列式的代码的最后一部分似乎有问题。我正在使用Code::Blocks编码。

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

main()
{
    int A[100][100];
    int i,j,k,n,res;
    printf("Enter the order of the matrix: \n");
    scanf("%d",&n);
    printf("\nEnter the elements of the matrix one by one: \n");
    for(i = 0 ; i < n ; i++)
    {
        for(j = 0 ; j < n ; j++)
        {
            scanf("%d",&A[i][j]);
        }
    }
    for(i = 0 ; i < n ; i++)
    {
        for(j = 0 ; j < n ; j++)
        {
            printf("%5d",A[i][j]);
        }
        printf("\n");
    }
    res = det(A,n);
    printf("%d",res);
}
int det(int A[100][100], int n)
{
    int Minor[100][100];
    int i,j,k,c1,c2;
    int determinant;
    int c[100];
    int O=1;

    if(n == 2)
    {
        determinant = 0;
        determinant = A[0][0]*A[1][1]-A[0][1]*A[1][0];
        return determinant;
    }
    else
    {
        for(i = 0 ; i < n ; i++)
        {
            c1 = 0, c2 = 0;
            for(j = 0 ; j < n ; j++)
            {
                for(k = 0 ; k < n ; k++)
                {
                    if(j != 0 && k != i)
                    {
                        Minor[c1][c2] = A[j][k];
                        c2++;
                        if(c2>n-2)
                        {
                            c1++;
                            c2=0;
                        }
                    }
                }
            }
            determinant = determinant + O*(A[0][i]*det(Minor,n-1));
            O=-1*O;
        }
    }
    return determinant;
}

- Edward

---

顺便说一下，我不知道指针的任何东西，所以我实际上不能使用它们...是什么阻止你学习它们呢？它们很有用。 :) - Sourav Ghosh

我有一种感觉，你的问题不是在计算上，而是在输入方面... - Eugene Sh.

@Sourav Ghosh 我知道，但是对于这个特定的代码，我不能使用它们，我的教授说我们只能使用我们已经知道的东西:(。 - Edward

@Eugene 输入？怎么输入？ - Edward

你需要使用所有警告和调试信息进行编译（例如，如果使用GCC，则为gcc -Wall -Wextra -g），改进代码直到没有警告，并且你应该使用调试器（gdb）。 - Basile Starynkevitch

Answer 1

在函数det()中，你只有在必要时才初始化了determinant。

determinant = 0;
determinant = A[0][0]*A[1][1]-A[0][1]*A[1][0];

但是当需要的时候

determinant = determinant + O*(A[0][i]*det(Minor,n-1));

没有先前的初始化。所以移动

determinant = 0;

在函数的开始附近，将 if(n == 2) 改为如下形式：

- Weather Vane

Answer 2

我设计了一个递归但高效且易于理解的算法来计算NxN矩阵的行列式：

int determinantOrderN(int **m, int n)
{
    int i,j,k, factor=1, det=0; int **newm;
    if(m==NULL) return -1;
    if (n==1) return **m; //when matrix is a number, determinant is the number
    for(i=0; i<n; i++) 
    {
        if(NULL == (newm = malloc((n-1) * sizeof(int *)))) return -1;
        for(j=0; j<n-1; j++) if (NULL == (newm[j] = malloc((n-1) * sizeof(int)))) return -1;
        for(j=1; j<n; j++) 
        {
            //skip first row as we dont need it for the adjunt matrixes
            for (k=0; k<n; k++)
            {
                if(k==i) continue; //skip same column
                nuevam[j-1][k<i?k:(k-1)]=m[j][k]; //asign the number to new matrix
            }
        }
        det+= factor*m[0][i]*determinantOrderN(newm, n-1); //recursivity, determinant of the adjunt matrix
        factor*=-1;
        for(j=0;j<orden-1;j++) free(newm[j]);
        free(newm);
    }
    return det;
}

使用方法类似于：

int **matrix, i;
matrix = malloc(3*sizeof(int *));
for(i=0; i<3;i++) matrix[i]=malloc(3*sizeof(int));
//asign all the numbers
printf("%d\n", determinantOrderN(matrix, 3));

- S_Rollan

Answer 3

只是为了补充其他答案，你也可以这样定义它：

int det(int n, int [n][n]);

实现方式如下：

int det(int n, int matrix[n][n])
{

}

这样，您就不必费心使用指向指针或动态分配内存的麻烦了。此外，函数定义几乎可以在任何地方工作，并且不需要预定义全局变量。

- Mehrshad Khansarian

Answer 4

这是一个计算任意MxN矩阵行列式的C程序：

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

int m,n; // original matrix dimensions

int det(int B[m][n]);

int main() {
    int determinant;
    register int row,column;

    printf("Enter rows and columns\n");
    scanf("%d%d",&m,&n);
    
    int A[m][n];

    printf("Enter matrix elements\n");

    for(row = 0; row < m; row++)
        for(column = 0; column < n; column++)
            scanf("%d",&A[row][column]);
            
    determinant = det(A);

    printf("determinant = %d \n",determinant);

    return 0;
}

int det(int B[m][n]) {
    int row_size = m;
    int column_size = n;

    if (row_size != column_size) {
        printf("DimensionError: Operation Not Permitted \n");
        exit(1);
    }

    else if (row_size == 1)
        return (B[0][0]);

    else if (row_size == 2)
        return (B[0][0]*B[1][1] - B[1][0]*B[0][1]);

    else {
        int minor[row_size-1][column_size-1];
        int row_minor, column_minor;
        int firstrow_columnindex;
        int sum = 0;

        register int row,column;

        // exclude first row and current column
        for(firstrow_columnindex = 0; firstrow_columnindex < row_size;
                firstrow_columnindex++) {

            row_minor = 0;

            for(row = 1; row < row_size; row++) {

                column_minor = 0;

                for(column = 0; column < column_size; column++) {
                    if (column == firstrow_columnindex)
                        continue;
                    else
                        minor[row_minor][column_minor] = B[row][column];

                    column_minor++;
                }

                row_minor++;
            }

            m = row_minor;
            n = column_minor;

            if (firstrow_columnindex % 2 == 0)
                sum += B[0][firstrow_columnindex] * det(minor);
            else
                sum -= B[0][firstrow_columnindex] * det(minor);

        }

        return sum;

    }
}                                                                                                                          

- nikinbaidar