C语言稀疏矩阵表示异常问题求助

你的代码存在几个关键问题，导致运行异常，下面逐一说明并修复：

1. 函数参数不匹配导致数组越界 #

display函数中声明的sparse[][5]是固定列数为5的二维数组，但你实际传入的是列数为c（非零元素个数）的可变长度数组（VLA）。这会导致函数内部访问数组时出现越界访问，读取到错误的内存数据，表现为输出混乱或随机数。

修复：将display函数的参数改为接受可变列数的二维数组，同时明确行数为3：

void display(int c, int sparse[3][c])

2. 可变长度数组（VLA）的兼容性问题 #

部分旧版C编译器可能对VLA支持不完善，或者在某些编译模式下会报错。如果遇到声明int sparse[3][c];的错误提示，可以改用动态内存分配来替代VLA，避免兼容性问题：

替换原来的int k = 0, sparse[3][c];为：

int k = 0;
// 动态分配3行c列的二维数组
int **sparse = malloc(3 * sizeof(int *));
for (int i = 0; i < 3; i++) {
    sparse[i] = malloc(c * sizeof(int));
}

同时，在程序结束前需要释放内存，避免内存泄漏：

// 释放动态分配的内存
for (int i = 0; i < 3; i++) {
    free(sparse[i]);
}
free(sparse);

对应的display函数参数也要改为指针形式：

void display(int c, int **sparse)

3. 稀疏矩阵的初始化逻辑验证 #

你的初始化逻辑本身是正确的，但因为前面的参数问题导致输出异常。修复参数后，第一个非零元素4的行号0、列号2、值4会正确出现在对应位置，输出符合预期。另外注意：你原数组中的非零元素实际是6个（4、7、9、6、3、2），并非7个。

完整修复后的代码 #

方案一：使用可变长度数组（适合支持C99及以上的编译器） #

#include <stdio.h>
#include <stdlib.h>

void display(int c, int sparse[3][c])
{
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < c; j++)
        {
            printf("%d ", sparse[i][j]);
        }
        printf("\n");
    }
}

int main()
{
    int c = 0, array[5][5] = {
        { 0, 0, 4, 0, 0 },
        { 0, 7, 0, 0, 0 },
        { 0, 0, 0, 9, 0 },
        { 0, 6, 0, 3, 0 },
        { 0, 0, 2, 0, 0 }
    };

    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if (array[i][j] != 0)
            {
                c++;
            }
        }
    }

    int k = 0, sparse[3][c];
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if (array[i][j] != 0)
            {
                sparse[0][k] = i;
                sparse[1][k] = j;
                sparse[2][k] = array[i][j];
                k++;
            }
        }
    }
    display(c, sparse);
    return 0;
}

方案二：使用动态内存分配（兼容性更好） #

#include <stdio.h>
#include <stdlib.h>

void display(int c, int **sparse)
{
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < c; j++)
        {
            printf("%d ", sparse[i][j]);
        }
        printf("\n");
    }
}

int main()
{
    int c = 0, array[5][5] = {
        { 0, 0, 4, 0, 0 },
        { 0, 7, 0, 0, 0 },
        { 0, 0, 0, 9, 0 },
        { 0, 6, 0, 3, 0 },
        { 0, 0, 2, 0, 0 }
    };

    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if (array[i][j] != 0)
            {
                c++;
            }
        }
    }

    int k = 0;
    int **sparse = malloc(3 * sizeof(int *));
    for (int i = 0; i < 3; i++) {
        sparse[i] = malloc(c * sizeof(int));
    }

    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if (array[i][j] != 0)
            {
                sparse[0][k] = i;
                sparse[1][k] = j;
                sparse[2][k] = array[i][j];
                k++;
            }
        }
    }
    display(c, sparse);

    // 释放内存
    for (int i = 0; i < 3; i++) {
        free(sparse[i]);
    }
    free(sparse);

    return 0;
}

预期输出 #

修复后运行代码，会输出：

0 1 2 3 3 4 
2 1 3 1 3 2 
4 7 9 6 3 2 

内容的提问来源于stack exchange，提问作者Yash Sachdeva