Question

我试图创建一个从较大矩阵返回子矩阵的函数。功能是

double **getSubmatrix(double **matrix, int n, int m, int row1, int row2, int col1, int col2){
int i, j, subrow, subcol;
subrow = 0;
subcol = 0;
int numSubRows = row2 - row1 + 1;
int numSubCols = col2 - col1 + 1;

// Create Submatrix with indicated size
double **subMatrix = (double **)malloc(sizeof(double *) * numSubRows);
for (i = 0; i < numSubRows; i++) {
    subMatrix[i] = (double *)malloc(sizeof(double) * numSubCols);
}
// Add values from matrix into subMatrix
for (i = row1; i <= row2; i++) {
    for (j = col1; j <= col2; j++) {
        subMatrix[subrow][subcol] = matrix[i][j];
        subcol += 1;
    }
    subrow += 1;
}
return subMatrix;

}

对该功能的调用是

mat2 = getSubmatrix(mat1, 3, 4, 1, 2, 2, 3)

mat1是一个3x4矩阵，其值为

8  2  4  1
10 4  2  3
12 42 1  0

我希望subMatrix返回

矩阵

2  3
1  0

但我只是

2  3
0  0

因为SubMatrix变为

2  3  0  0
0  0  1  0

还有段错误，即使numSubRows和numSubCols都是2.我觉得我错过了一些明显的东西，但我不确定它是什么。

Answer 1

for (i = row1; i <= row2; i++) {
    for (j = col1; j <= col2; j++) {
        subMatrix[subrow][subcol] = matrix[i][j];
        subcol += 1;
    }
    subrow += 1;
}

在上面的循环中，在递增subcol时，您无法将subrow设置回零。这就是为什么你会看到级联效应（未标记的单元格标记为.以使其更明显）：

2 3 . .
. . 1 0

而不是：

2 3
1 0

代码，如果您希望进行最小的必要更改，应该：

for (i = row1; i <= row2; i++) {
    for (j = col1; j <= col2; j++) {
        subMatrix[subrow][subcol] = matrix[i][j];
        subcol += 1;
    }
    subrow += 1;
    subcol = 0;  // added this line.
}

但是，由于您在两个维度中都使用固定基础，因此实际上可能更好地放弃这些subXXX变量：

for (i = row1; i <= row2; i++)
    for (j = col1; j <= col2; j++)
        subMatrix[i-row1][j-col1] = matrix[i][j];

另外两件事我想提一下。首先，您通常总是检查malloc()的返回值，即使您只使用它来退出并显示错误消息。这比继续使用将要更难调试的未定义行为更容易接受。

并且，在C中，您不应该从malloc()转换返回值。 C非常能够隐式地将void *返回值转换为任何其他指针类型，并且显式转换可以隐藏某些微妙的错误。

有关更强大的变体，请参阅以下内容。它提前做了很多理智检查，以确保你没有做出“奇怪”的事情。它还可以检测分配内存的问题，并在必要时自行清理。

它还有一个额外的功能，即自动填充变量（如果你提供它们）和子矩阵的高度和宽度。如果您提供NULL而不是指针，则不会担心它。

#include <stdlib.h>

double **getSubmatrix (
    double **matrix,
    int height, int width,
    int row1, int row2,
    int col1, int col2,
    int *pHeight, int *pWidth
) {
    // Check parameters for validity up front.

    if ((row1 < 0) || (row1 >= height))
        return NULL;
    if ((row2 < 0) || (row2 >= height))
        return NULL;
    if (row2 < row1)
        return NULL;

    if ((col1 < 0) || (col1 >= width))
        return NULL;
    if ((col2 < 0) || (col2 >= width))
        return NULL;
    if (col2 < col1)
        return NULL;

    // Allocate first level, return NULL if no good.

    double **subMatrix = malloc(sizeof(double *) * (row2 - row1 + 1));
    if (subMatrix == NULL) return NULL;

    // Allocate second level. If any fail, free all previous.

    for (int row = row1; row <= row2; row++) {
        subMatrix[row - row1] = malloc (sizeof(double) * (col2 - col1 + 1));
        if (subMatrix[row - row1] == NULL) {
            for (int rowfree = 0; rowfree < row; rowfree++) {
                free (subMatrix[rowfree]);
            }
            free (subMatrix);
            return NULL;
        }
    }

    // Now have fully allocated sub-matrix, give size if desired.

    if (pHeight != NULL)
        *pHeight = row2 - row1 + 1;

    if (pWidth != NULL)
        *pWidth = col2 - col1 + 1;

    // Transfer the sub-matrix data and return it.

    for (int row = row1; row <= row2; row++)
        for (int col = col1; col <= col2; col++)
            subMatrix[row - row1][col - col1] = matrix[row][col];

    return subMatrix;
}

您可以使用以下测试工具查看它。

#include <stdio.h>

int main (void) {
    double **ipp = malloc (sizeof (double *) * 3);

    ipp[0] = malloc (sizeof (double) * 4);
    ipp[1] = malloc (sizeof (double) * 4);
    ipp[2] = malloc (sizeof (double) * 4);

    ipp[0][0] =  8; ipp[0][1] =  2; ipp[0][2] =  4; ipp[0][3] =  1;
    ipp[1][0] = 10; ipp[1][1] =  4; ipp[1][2] =  2; ipp[1][3] =  3;
    ipp[2][0] = 12; ipp[2][1] = 42; ipp[2][2] =  1; ipp[2][3] =  0;

    for (int row = 0; row < 3; row++) {
        for (int col = 0; col < 4; col++) {
            printf ("%5.2f ", ipp[row][col]);
        }
        putchar ('\n');
    }

    putchar ('\n');
    int h, w;
    double **part = getSubmatrix (ipp, 3, 4, 1, 2, 2, 3, &h, &w);
    if (part == NULL) {
        puts ("Could not get sub-matrix");
    } else {
        for (int row = 0; row < h; row++) {
            for (int col = 0; col < w; col++) {
                printf ("%5.2f ", part[row][col]);
            }
            putchar ('\n');
        }
    }

    return 0;
}

Answer 2

为避免此类错误，您可以在subrow循环中增加/初始化subcol和for。

for (i = row1, subrow = 0; i <= row2; i++, ++subrow) {
   for (j = col1, subcol = 0; j <= col2; j++, ++subcol) {
      subMatrix[subrow][subcol] = matrix[i][j];
   }
}

为什么这个矩阵初始化为2x4而不是2x2？

2 个答案: