使用c语言，编制一个能演示稀疏矩阵相加、相减、相乘、转置的程序。 (1)以带行逻辑链接信息的三元组顺序表表示稀疏矩阵。 (2)实现两个矩阵的相加、相减、相乘和矩阵转置。 (3)稀疏矩阵的输入形式可采用...

好的，以下是程序实现的代码：

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

#define MAXSIZE 100

typedef struct {
    int i, j;
    int e;
} Triple; // 三元组结构体

typedef struct {
    Triple data[MAXSIZE + 1]; // 三元组顺序表
    int mu, nu, tu; // 稀疏矩阵的行数、列数、非零元素个数
} TSMatrix;

// 构造稀疏矩阵
void CreateMatrix(TSMatrix *M) {
    int m, n, t;
    printf("请输入稀疏矩阵的行数、列数、非零元素个数：\n");
    scanf("%d %d %d", &m, &n, &t);
    M->mu = m;
    M->nu = n;
    M->tu = t;
    printf("请输入三元组表中每个元素的行、列、值：\n");
    for (int i = 1; i <= t; i++) {
        scanf("%d %d %d", &M->data[i].i, &M->data[i].j, &M->data[i].e);
    }
}

// 矩阵转置
void TransposeMatrix(TSMatrix M, TSMatrix *T) {
    T->mu = M.nu;
    T->nu = M.mu;
    T->tu = M.tu;
    if (T->tu) {
        int q = 1;
        for (int col = 1; col <= M.nu; col++) {
            for (int p = 1; p <= M.tu; p++) {
                if (M.data[p].j == col) {
                    T->data[q].i = M.data[p].j;
                    T->data[q].j = M.data[p].i;
                    T->data[q].e = M.data[p].e;
                    q++;
                }
            }
        }
    }
}

// 稀疏矩阵相加
void AddMatrix(TSMatrix M1, TSMatrix M2, TSMatrix *M3) {
    if (M1.mu != M2.mu || M1.nu != M2.nu) {
        printf("两个矩阵的行列数不同，无法相加！\n");
        M3->tu = 0;
        return;
    }
    int i = 1, j = 1, k = 1;
    while (i <= M1.tu && j <= M2.tu) {
        if (M1.data[i].i < M2.data[j].i || (M1.data[i].i == M2.data[j].i && M1.data[i].j < M2.data[j].j)) {
            M3->data[k++] = M1.data[i++];
        } else if (M1.data[i].i == M2.data[j].i && M1.data[i].j == M2.data[j].j) {
            int e = M1.data[i].e + M2.data[j].e;
            if (e != 0) {
                M3->data[k].i = M1.data[i].i;
                M3->data[k].j = M1.data[i].j;
                M3->data[k].e = e;
                k++;
            }
            i++;
            j++;
        } else {
            M3->data[k++] = M2.data[j++];
        }
    }
    while (i <= M1.tu) {
        M3->data[k++] = M1.data[i++];
    }
    while (j <= M2.tu) {
        M3->data[k++] = M2.data[j++];
    }
    M3->mu = M1.mu;
    M3->nu = M1.nu;
    M3->tu = k - 1;
}

// 稀疏矩阵相减
void SubMatrix(TSMatrix M1, TSMatrix M2, TSMatrix *M3) {
    if (M1.mu != M2.mu || M1.nu != M2.nu) {
        printf("两个矩阵的行列数不同，无法相减！\n");
        M3->tu = 0;
        return;
    }
    int i = 1, j = 1, k = 1;
    while (i <= M1.tu && j <= M2.tu) {
        if (M1.data[i].i < M2.data[j].i || (M1.data[i].i == M2.data[j].i && M1.data[i].j < M2.data[j].j)) {
            M3->data[k++] = M1.data[i++];
        } else if (M1.data[i].i == M2.data[j].i && M1.data[i].j == M2.data[j].j) {
            int e = M1.data[i].e - M2.data[j].e;
            if (e != 0) {
                M3->data[k].i = M1.data[i].i;
                M3->data[k].j = M1.data[i].j;
                M3->data[k].e = e;
                k++;
            }
            i++;
            j++;
        } else {
            M3->data[k++] = M2.data[j++];
        }
    }
    while (i <= M1.tu) {
        M3->data[k++] = M1.data[i++];
    }
    while (j <= M2.tu) {
        M3->data[k].i = M2.data[j].i;
        M3->data[k].j = M2.data[j].j;
        M3->data[k++].e = -M2.data[j++].e;
    }
    M3->mu = M1.mu;
    M3->nu = M1.nu;
    M3->tu = k - 1;
}

// 稀疏矩阵相乘
void MultMatrix(TSMatrix M1, TSMatrix M2, TSMatrix *M3) {
    if (M1.nu != M2.mu) {
        printf("两个矩阵无法相乘！\n");
        M3->tu = 0;
        return;
    }
    int q = 1;
    int tpot[MAXSIZE + 1] = {0}; // 存储M2矩阵中每一列的第一个非零元素在b数组中的位置
    for (int col = 1; col <= M2.nu; col++) {
        for (int p = 1; p <= M2.tu; p++) {
            if (M2.data[p].j == col) {
                tpot[col] = p;
                break;
            }
        }
    }
    for (int row = 1; row <= M1.mu; row++) {
        int c[MAXSIZE + 1] = {0}; // 存储M3矩阵中每一行的值
        for (int p = tpot[1]; p <= M2.tu; p++) {
            int col = M2.data[p].j;
            if (col > M1.nu) {
                break;
            }
            if (tpot[col] == 0) {
                continue;
            }
            int q1 = tpot[col];
            int q2 = p;
            while (q1 <= M1.tu && M1.data[q1].i == row && q2 <= M2.tu && M2.data[q2].j == col) {
                if (M1.data[q1].j < M2.data[q2].i) {
                    q1++;
                } else if (M1.data[q1].j > M2.data[q2].i) {
                    q2++;
                } else {
                    c[col] += M1.data[q1].e * M2.data[q2].e;
                    q1++;
                    q2++;
                }
            }
        }
        for (int col = 1; col <= M1.nu; col++) {
            if (c[col] != 0) {
                M3->data[q].i = row;
                M3->data[q].j = col;
                M3->data[q].e = c[col];
                q++;
            }
        }
    }
    M3->mu = M1.mu;
    M3->nu = M2.nu;
    M3->tu = q - 1;
}

// 输出稀疏矩阵
void PrintMatrix(TSMatrix M) {
    printf("稀疏矩阵的三元组表：\n");
    printf("行 列 值\n");
    for (int i = 1; i <= M.tu; i++) {
        printf("%2d %2d %2d\n", M.data[i].i, M.data[i].j, M.data[i].e);
    }
}

int main() {
    TSMatrix M1, M2, M3;
    printf("请输入第一个稀疏矩阵：\n");
    CreateMatrix(&M1);
    printf("第一个稀疏矩阵为：\n");
    PrintMatrix(M1);
    printf("请输入第二个稀疏矩阵：\n");
    CreateMatrix(&M2);
    printf("第二个稀疏矩阵为：\n");
    PrintMatrix(M2);
    printf("第一个稀疏矩阵的转置矩阵为：\n");
    TransposeMatrix(M1, &M3);
    PrintMatrix(M3);
    printf("第二个稀疏矩阵的转置矩阵为：\n");
    TransposeMatrix(M2, &M3);
    PrintMatrix(M3);
    printf("两个稀疏矩阵相加的结果为：\n");
    AddMatrix(M1, M2, &M3);
    PrintMatrix(M3);
    printf("两个稀疏矩阵相减的结果为：\n");
    SubMatrix(M1, M2, &M3);
    PrintMatrix(M3);
    printf("两个稀疏矩阵相乘的结果为：\n");
    MultMatrix(M1, M2, &M3);
    PrintMatrix(M3);
    return 0;
}

程序中使用了三元组顺序表来表示稀疏矩阵，具体实现了矩阵的转置、相加、相减、相乘等功能。在程序运行时，先输入两个稀疏矩阵的信息，然后分别输出它们的转置矩阵和相加、相减、相乘的结果。