在阵列中寻找对称性

Question

嗨，我需要检查一下阵列是否对称。我有一个函数，它将整数的二维数组M和行和列的数组大小作为参数，如果M是对称的，则返回1。我尝试了很多次，但是输出结果要么是非对称数组的，要么是不对称数组的。

这是我的代码：

#include <stdio.h>
#define SIZE 10
#define INIT_VALUE -1
int symmetry2D(int M[][SIZE], int rowSize, int colSize);
int main()
{
    int M[SIZE][SIZE], i, j, result = INIT_VALUE;
    int rowSize, colSize;
    printf("Enter the array size (rowSize, colSize): \n");
    scanf("%d %d", &rowSize, &colSize);
    printf("Enter the matrix (%dx%d): \n", rowSize, colSize);
    for (i = 0; i < rowSize; i++)
        for (j = 0; j < colSize; j++)
            scanf("%d", &M[i][j]);
    result = symmetry2D(M, rowSize, colSize);
    if (result == 1)
        printf("symmetry2D(): No\n");
    else if (result == 0)
        printf("symmetry2D(): Yes\n");
    else
        printf("Error\n");
    return 0;
}

int symmetry2D(int M[][SIZE], int rowSize, int colSize)
{
    int h, k, temp;
    int result;

    for (h = 0; h < rowSize; h++)
    {
        for (k = 0; k < colSize; k++)
        {
            M[h][k] = M[k][h];
        }

    }

    result = 0;
    for (h = 0; h < rowSize && result; h++)
    {
        for (k = 0; k < colSize; k++)
        {
            //if it is not equal to its transpose
            if (M[h][k] != M[h][k])
            {
                result = 1;
                break;
            }

        }
    }

    if (result == 0)
    {
        for (h = 0; h < rowSize; h++)
        {
            for (k = 0; k < colSize; k++)
            {
                return result = 0;
            }

        }

    }
    else
        return result = 1;
}

Answer 1

若干问题：

1. 根据你的定义，矩阵是对称的当且仅当它等于它的转置。这只能适用于方阵，但你也可以容纳非方阵，没有明显的理由。
2. 您的symmetry2D()函数包含严重的逻辑缺陷：

- It _makes_ the input symmetric via the loop that performs `M[h][k] = M[k][h]`
- Even if it did not do so, it would never find the input non-symmetric, because its test for that is `if (M[h][k] != M[h][k])`, which must always fail.

​

1. 还不清楚您认为if/else和symmetry2D()末尾的循环嵌套为您实现了什么，但前提是rowSize和colSize都大于零，整个构造的实际效果与简单的return result;相同。

看起来，这个想法可能是创建一个包含输入转置的数组，然后将输入与之进行比较。这是可行的，尽管效率很低，但实际上您从来没有为转置创建过单独的数组。如果你要在不创建转位的情况下进行测试--你应该--然后

1. 不要修改输入数组(因此完全删除第一个循环嵌套)。
2. 为对称比较建立索引：M[h][k] != M[k][h]
3. 为了达到最佳的效率，避免重复和不必要的比较。例如，如果您已经测试了M[1][2] == M[2][1]，那么就不需要测试M[2][1] == M[1][2]是否。而且你也不需要在主对角线上测试元素。通过更好的循环边界选择，您可以很容易地实现这一效率。

此外，如果symmetry2D()函数确实应该避免修改输入数组，请考虑将其第一个参数的元素类型声明为const int，而不是普通的int (但不要修改main()中相应变量的类型)。如果您一开始就这样编写它，那么编译器就会注意到函数在逻辑上错误地试图修改数组元素，并拒绝了代码。