Question

所以，我递归地计算可变大小数组的行列式。所以，如果你熟悉如何计算决定因素，这里有一张显示我正在做的事情的图片：

我无法发布图片，因为我没有足够的代表。这是一个链接：

http://i.stack.imgur.com/gIW1D.png

所以，让我非常困惑的部分是制作更小的2x2矩阵。（请记住，我正在编写此代码以适用于任何大小的数组，而不仅仅是3x3）。

所以我并没有真正询问如何计算行列式，我只能采用上面显示的3x3阵列，只访问显示的部分。

Answer 1

因此，要计算NxN矩阵的行列式，您需要删除第一行，然后逐个删除列，并计算得到的（N-1）x（N-1）矩阵束的行列式。要计算这些决定因素，您需要敲击较小矩阵的第一行（这将是原始矩阵的第二行），然后逐个删除其他列，依此类推。

因此，很容易弄清楚如何处理每个递归级别的行：在级别0，您将通过第0行，在级别1，您将通过级别1，依此类推。

但是列更多涉及。如果在0级，你会击出第7行，在第1级你会击出当前矩阵的第12行（这将是原始矩阵的第13行）并且2级你会击出当前矩阵的第10行，这也是矩阵上一层的第10行，这是矩阵的第11行两个级别up ，这是原始矩阵......要确定在递归的较低级别访问原始矩阵的哪一列是非常困难的。

当然可以复制整个矩阵，没有应该删除的列，并将副本传递给递归级别。但那会很浪费。

删除列数字而不是列本身更为优雅。为此，我们创建了一个列号的一维数组。最初它应按顺序包含数字0 ..（N-1）。在准备计算每个子矩阵行列式时，复制该数组，从副本中删除一个列索引，然后将其传递给递归计算。

所以你的递归函数看起来大概就像这样（在伪代码中）

float recursive_determinant (int N, float[N][N] matrix, 
                             int[N] column_array, int level)

    if level == N-1
      return matrix[level][column_array[0]]

    result = 0
    for each i in 0 .. N - level
       copy_of_column_array = column_array
       copy_of_column_array.remove_element(i)
       subdeterminant = recursive_determinant (N, matrix, 
                                               copy_of_column_array, level+1)
       result = result + subdeterminant * 
                         matrix[level][column_array[i]] * (-1)^(i+1)
    return result


 float determinant (int N, float[N][N] matrix)
     result = recursive_determinant (N, matrix, {0, 1, ..., N-1}, 0)

Answer 2

根据您的图像，您拥有的是具有3x3元素的2D数组，并且您希望使用该2D数组的某些元素进行计算。您的2D数组声明为int firstarray[xsize][ysize]。当然，如果它是xsize，ysize或ysize，xsize取决于你喜欢使用它的方式。在这个特定的情况下，你给它的是int firstarray[3][3]。

然后，您可以通过获取firstarray的相应元素来访问较小的数组。

Answer 3

以下是动态分配的数组的一些示例：1,2,3和4维：

int * Create1D(int r)
    {   
        int *space; 
        int *arr;

        space = calloc(r*sizeof(int), sizeof(int));
        arr   = calloc(sizeof(int), sizeof(int));
        arr = (int *)space;

        return arr;
    }

    int ** Create2D(int c, int r)
    {   
        int *space; 
        int **arr;
        int    y;

        space   = calloc(c*r*sizeof(int), sizeof(int));
        arr   = calloc(c * sizeof(int *), sizeof(int));
        for(y=0;y<c;y++)
        {
            arr[y] = (int *)space + (y*r);   
        }
        return arr;
    }

    int *** Create3D(int p, int c, int r) 
    {
        int *space;
        int ***arr;
        int    x,y;

        space = calloc (p*c*r*sizeof(int),sizeof(int));
        arr = calloc(p * sizeof(int **), sizeof(int));
        for(x = 0; x < p; x++)
        {
            arr[x] = calloc(c * sizeof(int *),sizeof(int));
            for(y = 0; y < c; y++)
            {
                arr[x][y] = ((int *)space + (x*(c*r) + y*r));
            }
        }
        return arr;
    }

    int **** Create4D(int hR, int p, int c, int r)     
    {
        int *space;
        int ****arr;
        int    w,x,y;

        space = calloc(hR*p*c*r*sizeof(int), sizeof(int));
        arr = calloc(hR * sizeof(int ***), sizeof(int));
        for(w=0;w<hR;w++)
        {
            arr[w] = calloc(p * sizeof(int **), sizeof(int));
            for(x=0;x<p;x++)
            {
                arr[w][x] = calloc(c * sizeof(int *), sizeof(int));
                for(y=0;y<c;y++)
                {                                        
                    arr[w][x][y] = ((int *)space + (w*(p*c*r) + x*(c*r) + y*r)); 
                }
            }
        }
        return arr;
    }

这种方法可以扩展到您想要的多个维度。完成后不要忘记自由陈述。

C：需要将二维数组的某些部分写入新的二维数组

3 个答案: