C语言实现稀疏矩阵相加算法：三元组顺序表存储结构

typedef struct{
    int i; //行下标
    int j; //列下标
    int e; //元素值
}Triple;

typedef struct{
    Triple data[MAXSIZE+1];
    int mu; //行数
    int nu; //列数
    int tu; //非零元个数
}TSMatrix;

BOOL TSMatrixAdd(TSMatrix A, TSMatrix B, TSMatrix &C){
    if(A.mu != B.mu || A.nu != B.nu){
        return false; //两个矩阵不同阶，无法相加
    }
    C.mu = A.mu;
    C.nu = A.nu;
    int i = 1, j = 1, k = 0;
    while(i <= A.tu && j <= B.tu){
        if(A.data[i].i < B.data[j].i){
            C.data[++k] = A.data[i++];
        }else if(A.data[i].i > B.data[j].i){
            C.data[++k] = B.data[j++];
        }else{
            if(A.data[i].j < B.data[j].j){
                C.data[++k] = A.data[i++];
            }else if(A.data[i].j > B.data[j].j){
                C.data[++k] = B.data[j++];
            }else{
                int sum = A.data[i].e + B.data[j].e;
                if(sum != 0){
                    C.data[++k].i = A.data[i].i;
                    C.data[k].j = A.data[i].j;
                    C.data[k].e = sum;
                }
                i++;
                j++;
            }
        }
    }
    while(i <= A.tu){
        C.data[++k] = A.data[i++];
    }
    while(j <= B.tu){
        C.data[++k] = B.data[j++];
    }
    C.tu = k;
    return true;
}

算法思路：

1. 首先判断两个矩阵是否同阶，如果不同阶则无法相加，返回 false。
2. 初始化结果矩阵 C 的行数、列数和非零元个数。
3. 使用三个指针 i、j 和 k 分别指向矩阵 A、B 和 C 的非零元。
4. 依次比较 A 和 B 中对应元素的行下标和列下标，将较小的元素添加到 C 中，并更新指针。
5. 如果 A 和 B 中对应元素的行下标和列下标都相同，则将两个元素的值相加，如果结果不为 0，则将结果添加到 C 中，并更新指针。
6. 当 A 或 B 中的非零元遍历完之后，将剩余的非零元直接添加到 C 中。
7. 最后更新 C 的非零元个数，返回 true 表示相加成功。

代码解释：

• TSMatrix 结构体表示三元组顺序表，包含 data 数组存储非零元信息，mu 表示行数，nu 表示列数，tu 表示非零元个数。
• TSMatrixAdd 函数实现矩阵相加操作，参数为两个待相加的矩阵 A 和 B，以及结果矩阵 C 的引用。
• 代码中使用 while 循环遍历两个矩阵的非零元，并根据元素下标进行比较，将结果添加到 C 中。
• 使用 if 语句判断元素值是否为 0，如果为 0 则不添加到 C 中，避免出现 0 值的非零元。
• 最后将 C 的非零元个数更新为 k，并返回 true 表示相加成功。

示例：

假设矩阵 A 和 B 分别为：

     1  0  0
  A = 0  2  0
     0  0  3

     0  1  0
  B = 2  0  0
     0  0  1

则相加后的结果矩阵 C 为：

     1  1  0
  C = 2  2  0
     0  0  4