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

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行，这是原始矩阵...很难确定要在较低递归级别访问原始矩阵的哪一列。

当然，可以复制整个矩阵，不删除应删除的列，然后将副本传递到递归级别。 但这将是相当浪费的。

删除列号而不是列本身更为优雅。 为此，我们创建一个一维的列号数组。 最初，它应按顺序包含数字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;
    }

您可以将这种方法扩展到任意多个维度。 完成后不要忘记免费的声明。