Question

我编写了一个程序，使用递归（拉普拉斯定理）找到n×n矩阵的行列式。

它们是三个功能

1）determinant（）找到n * n矩阵的行列式

2）create（）动态分配n * n数组

3）copy（）创建n * 1数组的n-1 * n-1次要

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int determinant(int **a,int size,int noentry);// find determinant using recursion
int copy(int **b,int **a,int size,int noentry);//copy elements to minor
int **create(int size); // dynamically allocate a two dimensional array
 int main()
{
 int **a,size,i,j,y;
 printf("enter the order of the determinant \n");
 scanf("%d",&size);
 a=create(size);
 printf("enter your elements \n");
 for(i=0;i<size;i++)
{
    for(j=0;j<size;j++)
    {
        scanf("%d",&a[i][j]);
    }
 }
y=determinant(a,size,0);
printf("the determinant is %d \n",y);
 return 0;
}
int  determinant(int **a,int size,int noentry)
{
int i;
static int det=0;
if(size<=2)
    return a[0][0]*a[1][1]-a[0][1]*a[1][0];
else
{
    for(i=0;i<size;i++)
    {

        int **b;
        b=create(size-1);
        copy(b,a,size-1,i);
        det= det+pow(-1,i)*a[0][i]*determinant(b,size-1,i);
    }
    return det;
 }
}
int copy(int **b,int **a,int size,int noentry)
{
 int i,j,k;
 for(i=1;i<=size;i++)
{
    k=0;
    for(j=0;j<=size;j++)
    {
        if(j==noentry)
            continue;
        else
        {
            b[i-1][k]=a[i][j];
            k++;
        }
    }
}
return size;
}
int **create(int size)
{
 int **b;
 if(size<=0)
 {
    printf("the size cannot be negative/null \n");
    return NULL;
}
int i;
printf("entered the create function \n");
b=(int **)malloc(sizeof(int *)*size);
for(i=0;i<size;i++)
    b[i]=(int *)malloc(size*sizeof(int));
return b;
}

程序正在以3乘3矩阵正常工作，但对于4乘4矩阵没有，我无法发现错误。

Answer 1

首先，你永远不会释放分配的坏块。您应该创建一个destroy方法来释放先前分配的矩阵，并在每次create调用时调用一次。

接下来，您将未使用的noentry参数传递给determinant。它应该是：int determinant(int **a,int size);

但错误的原因在于determinant方法中，det变量是静态的。当您在determinant中递归时，每个新调用都应该有自己的det副本，或者共享相同的副本。

TL / DR：只需删除static函数中det变量的determinant限定符。

最后的建议：如果你分配了你的矩阵，那么调试会更容易......矩阵明智！

int **create(int size)
{
    int i;
    int **b;
    if(size<=0)
    {
        printf("the size cannot be negative/null \n");
        return NULL;
    }
    printf("entered the create function \n");
    b=(int **)malloc(sizeof(int *)*size);
    b[0]=(int *)malloc(size * size*sizeof(int));
    for(i=1;i<size;i++)
        b[i]=b[0] + i * size;
    return b;
}
void destroy(int **a) {
    free(a[0]);
    free(a);
}

这样整个矩阵使用连续内存，通过观察从a[0]开始的size²整数，可以在调试器中轻松查看其内容。而作为副作用，破坏功能很简单。

为了详尽无遗，固定的determinant函数变为：

int  determinant(int **a,int size)
{
    int i;
    int det=0;
    int m1 = 1;
    if(size<=2)
        return a[0][0]*a[1][1]-a[0][1]*a[1][0];
    else
    {
        for(i=0;i<size;i++)
        {

            int **b;
            b=create(size-1);
            copy(b,a,size-1,i);
            det= det+m1*a[0][i]*determinant(b,size-1);
            destroy(b);
            m1 = - m1;
        }
        return det;
    }
}

决定程序无法正常工作

1 个答案: