从行列式求值到线性方程组求解

第一部分：利用动态内存分配函数来创建一个类似数组的地址，之后利用递归函数降阶求出行列式的值

第二部分：利用克莱姆公式求解线性方程组的解

代码如下：如有不懂的可以评论

//计算线性方程组的解

//计算行列式函数
int calculate(int* arr, int order)
{
    int reslut = 0;

    if (order > 3)
    {
        int Col = 0;//创建行列式首行的下标
        for (Col = 0; Col < order; Col++)//遍历行列式首行
        {
            //另外开辟一个空间，存入余子式
            int* arr2 = (int*)malloc(sizeof(int) * (order - 1) * (order - 1));
            int row = 0;
            int col = 0;
            int num = 0;
            for (row = 1; row < order; row++)
            {
                for (col = 0; col < order; col++)
                {
                    if (Col == col)
                        continue;
                    arr2[num++] = arr[order * row + col];//将余子式存入另外一内存个空间
                }
            }
            int flag = 1;
            if (Col % 2)//奇数余子式前加负号
                flag = -1;
            reslut += arr[Col] * flag * calculate(arr2, order - 1);//递归函数来降阶求得
            free(arr2);
        }
    }
    else//直接计算行列式的值
    {
        switch (order)
        {
        case 1:
            reslut = arr[0];
            break;
        case 2:
            reslut = arr[0] * arr[3] - arr[1] * arr[2];
            break;
        case 3:
            reslut = arr[0] * (arr[4] * arr[8] - arr[5] * arr[7]) +
                arr[1] * (arr[5] * arr[6] - arr[3] * arr[8]) +
                arr[2] * (arr[3] * arr[7] - arr[4] * arr[6]);
            break;
        }
    }

    return reslut;

}


//输入行列式的值
int* input(int order)
{
    // malloc函数开辟动态内存空间，存放行列式的值
    int* arr = (int*)malloc(sizeof(int) * order * order);
    int row = 0;
    int col = 0;

    //输入行列式的值，通过首地址arr存入
    printf("依次输入行列式的值\n");
    for (row = 0; row < order; row++)
    {
        for (col = 0; col < order; col++)
        {
            scanf("%d", arr + order * row + col);
        }
    }

    return arr;

}

//交换行列式的第col列和一维向量
void change(int* arr, int* arr1, int row, int col, int n)
{
    int tmp = arr[row * n + col];
    arr[row * n + col] = arr1[row];
    arr1[row] = tmp;
}

void input_b(int*arr,int n,int result)
{
    // malloc函数开辟动态内存空间，存放一维向量的值
    int* arr1 = (int*)malloc(sizeof(int) * n);
    int row = 0;

    //输入一位向量的值，通过首地址arr1存入
    printf("依次输入B的值\n");
    
    int flag = n;//判断线性方程右边是否全为0，全为0 flag为0
    for (row = 0; row < n; row++)
    {
            scanf("%d", arr1 + row);
            if (!( * (arr1 + row)))
                flag--;
    }
    int col = 0;
    if (result)
    {
        if (flag)
        {
            printf("此方程组解为0\n");

        }
        else
        {
            for (col = 0; col < n; col++)
            {
                for (row = 0; row < n; row++)
                {
                    change(arr, arr1, row, col, n);
                }
                double result1 = calculate(arr, n);
                double x = result1 / result;//利用克莱姆法则求解x的值
                printf("x%d=%lf\n", col + 1, x);
                for (row = 0; row < n; row++)
                {
                    change(arr, arr1, row, col, n);
                }
            }
            free(arr1);
        }
    }
    else
    {
        if (flag)
        {
            printf("此方程组无解或者无穷解\n");
        }
        else
        {
            printf("此方程组有无穷解\n");
        }
        
    }
}


int main()
{
    int order = 0;
    do
    {
        printf("请输入行列式的阶数：");
        scanf("%d", &order);//输入行列式的阶数，便于等下创建动态空间

        //阶数小于0时输入错误，重新输入
        if (order <= 0)
        {
            printf("输入错误！请重新输入!!!\n");
        }
        else
        {
            int* arr = input(order);//函数input输入行列式的各个值
            int n = order;

            int reslut = calculate(arr, order);//计算行列式

            input_b(arr, n,reslut);

            free(arr);//释放内存

        }
    } while (1);//一直循环求行列式，不计算则关闭程序

    return 0;
}