二维数组可以来存放矩阵中的元素，比如int text[][5] = {{0,5,6,0,4},{0,0,0,0,0},{1,0,0,0,0},{1,0,0,0,0},{0,2,0,0,1}}; 但是这个矩阵，五行五列，可以包含二十五个元素，但是此矩阵只有七个元素。但是我们在存放数据的时候分配了二十五块int单元。这样是不是有点太浪费了。如果我们只存储这七个元素我想会节省一部分内存空间。但是如果我们只存储矩阵中的元素还是不行的，因为只有元素我们就无法还原矩阵，我们还需要此元素的行列值。我们声明一个结构体来表示一个元素。就像这样： typedef struct juzhen { int row; //行 int col; //列 int value; //元素值 }; 如果矩阵的行列是一个很大的值，而且又是稀疏矩阵，这样做就可以节省很大的空间。这种存储结构只限于稀疏矩阵。 请用此结构体来存储稀疏矩阵并进行矩阵的转置。结构体数组第一个元素存储矩阵的总行数，总列数和总元素个数，分别对应row,col,value. 程序的总体结构如下： 不考虑输入错误的情况。 #define MAX_TERM 80// 结构体数组最大长度 struct juzhen a[MAX_TERM]; //存放矩阵中元素数值不为零的元素 struct juzhen b[MAX_TERM]; //转置后的矩阵 void show(struct juzhen a[],int count_a) //显示稀疏矩阵方法 { printf(" i row col val\n"); printf(" %d| %d %d %d\n"); } void zhuanzhi(struct juzhen a[],struct juzhen b[]) //转置矩阵方法 void init(struct juzhen a[],int rows, int cols,int count) //初始化稀疏矩阵 int main(void) { printf("please input the number of rows,cols and values\n"); scanf("%d,%d,%d"); init(); show(); printf("\n"); zhuanzhi(); show(); } 程序运行如下： please input the number of rows,cols and values 2,2,2 please input the row,col and value 0,1,1 please input the row,col and value 1,0,2 i row col val 1| 0 1 1 2| 1 0 2 i row col val 1| 0 1 2 2| 1 0 1

下面是使用稀疏矩阵结构体进行存储和转置的代码：

#include <stdio.h>

#define MAX_TERM 80  // 结构体数组最大长度

struct juzhen {
    int row;        // 行
    int col;        // 列
    int value;      // 元素值
};

void show(struct juzhen a[], int count_a) { // 显示稀疏矩阵方法
    printf(" i row col val\n");
    for (int i = 0; i <= count_a; i++) {
        printf(" %d|  %d   %d   %d\n", i, a[i].row, a[i].col, a[i].value);
    }
}

void zhuanzhi(struct juzhen a[], struct juzhen b[]) {  // 转置矩阵方法
    int rows = a[0].row;
    int cols = a[0].col;
    int count = a[0].value;
    b[0].row = cols;
    b[0].col = rows;
    b[0].value = count;

    if (count == 0) { // 如果矩阵中元素数为0，则不需要转置
        return;
    }

    int row_terms[cols + 1]; // 存储每一列中元素的个数
    int start_pos[cols + 1]; // 存储每一列中第一个元素在b数组中的位置

    // 统计每一列中元素的个数
    for (int i = 1; i <= cols; i++) {
        row_terms[i] = 0;
    }
    for (int i = 1; i <= count; i++) {
        row_terms[a[i].col]++;
    }

    // 计算每一列中第一个元素在b数组中的位置
    start_pos[1] = 1;
    for (int i = 2; i <= cols; i++) {
        start_pos[i] = start_pos[i - 1] + row_terms[i - 1];
    }

    // 转置矩阵
    for (int i = 1; i <= count; i++) {
        int j = start_pos[a[i].col]++;
        b[j].row = a[i].col;
        b[j].col = a[i].row;
        b[j].value = a[i].value;
    }
}

void init(struct juzhen a[], int rows, int cols, int count) { // 初始化稀疏矩阵
    int index = 1;
    a[0].row = rows;
    a[0].col = cols;
    a[0].value = count;

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            int value;
            scanf("%d", &value);
            if (value != 0) {
                a[index].row = i;
                a[index].col = j;
                a[index].value = value;
                index++;
            }
        }
    }
}

int main(void) {
    int rows, cols, count;
    printf("please input the number of rows,cols and values\n");
    scanf("%d,%d,%d", &rows, &cols, &count);
    init(a, rows, cols, count);
    show(a, count);
    printf("\n");
    zhuanzhi(a, b);
    show(b, b[0].value);
    return 0;
}

这里使用了两个稀疏矩阵结构体数组，一个用于存储原始矩阵中元素值不为0的元素，另一个用于存储转置后的矩阵。在转置矩阵函数中，首先统计每一列中元素的个数，然后计算每一列中第一个元素在b数组中的位置，最后进行矩阵转置。