用c语言写两个同阶稀疏矩阵 A 和 B 分别都采用三元组表示，编写程序求 C = A - B，要求 C 也采用三元组表示。

好的，这是一个比较基础的矩阵运算问题，我们可以按照以下步骤进行解答：

1. 定义三元组结构体

首先，我们需要定义一个三元组结构体，用于存储矩阵的非零元素信息：

typedef struct {
    int row;  // 行下标
    int col;  // 列下标
    int value;  // 元素值
} Triple;

2. 定义稀疏矩阵结构体

接下来，我们定义一个稀疏矩阵结构体，用于存储矩阵的基本信息，包括矩阵的行数、列数、非零元素个数以及三元组数组：

typedef struct {
    int rows;  // 行数
    int cols;  // 列数
    int n;  // 非零元素个数
    Triple *data;  // 三元组数组
} SparseMatrix;

3. 编写矩阵减法函数

有了上述结构体定义，我们就可以编写矩阵减法函数了。具体实现思路如下：

- 首先，根据矩阵 A 和 B 的行列数和非零元素个数，创建稀疏矩阵 C。
- 然后，分别遍历矩阵 A 和 B 的三元组数组，对应位置进行减法运算，并将结果存储到矩阵 C 的三元组数组中。
- 最后，返回矩阵 C。

下面是完整的代码实现：

SparseMatrix substract(SparseMatrix A, SparseMatrix B) {
    // 创建稀疏矩阵 C
    SparseMatrix C;
    C.rows = A.rows;
    C.cols = A.cols;
    C.n = 0;
    C.data = (Triple *)malloc(sizeof(Triple) * (A.n + B.n));
    int i = 0, j = 0, k = 0;
    // 遍历矩阵 A 和 B 的三元组数组
    while (i < A.n && j < B.n) {
        if (A.data[i].row < B.data[j].row || (A.data[i].row == B.data[j].row && A.data[i].col < B.data[j].col)) {
            // A 中当前元素在 B 中没有对应元素，将其直接加入 C
            C.data[k].row = A.data[i].row;
            C.data[k].col = A.data[i].col;
            C.data[k].value = A.data[i].value;
            i++; k++;
        } else if (A.data[i].row == B.data[j].row && A.data[i].col == B.data[j].col) {
            // A 和 B 中当前元素在同一位置，做减法运算
            int value = A.data[i].value - B.data[j].value;
            if (value != 0) {
                C.data[k].row = A.data[i].row;
                C.data[k].col = A.data[i].col;
                C.data[k].value = value;
                k++;
            }
            i++; j++;
        } else {
            // B 中当前元素在 A 中没有对应元素，将其相反数加入 C
            C.data[k].row = B.data[j].row;
            C.data[k].col = B.data[j].col;
            C.data[k].value = -B.data[j].value;
            j++; k++;
        }
    }
    // 处理 A 或 B 中剩余的元素
    while (i < A.n) {
        C.data[k].row = A.data[i].row;
        C.data[k].col = A.data[i].col;
        C.data[k].value = A.data[i].value;
        i++; k++;
    }
    while (j < B.n) {
        C.data[k].row = B.data[j].row;
        C.data[k].col = B.data[j].col;
        C.data[k].value = -B.data[j].value;
        j++; k++;
    }
    // 更新 C 的非零元素个数
    C.n = k;
    return C;
}

4. 测试代码

最后，我们可以编写一个测试函数，用于验证矩阵减法函数的正确性：

void test() {
    // 定义矩阵 A
    SparseMatrix A;
    A.rows = 3;
    A.cols = 3;
    A.n = 4;
    A.data = (Triple *)malloc(sizeof(Triple) * A.n);
    A.data[0].row = 0;
    A.data[0].col = 0;
    A.data[0].value = 1;
    A.data[1].row = 1;
    A.data[1].col = 1;
    A.data[1].value = 2;
    A.data[2].row = 1;
    A.data[2].col = 2;
    A.data[2].value = 3;
    A.data[3].row = 2;
    A.data[3].col = 1;
    A.data[3].value = 4;
    // 定义矩阵 B
    SparseMatrix B;
    B.rows = 3;
    B.cols = 3;
    B.n = 3;
    B.data = (Triple *)malloc(sizeof(Triple) * B.n);
    B.data[0].row = 0;
    B.data[0].col = 0;
    B.data[0].value = 1;
    B.data[1].row = 1;
    B.data[1].col = 1;
    B.data[1].value = 3;
    B.data[2].row = 2;
    B.data[2].col = 1;
    B.data[2].value = 4;
    // 计算矩阵 C = A - B
    SparseMatrix C = substract(A, B);
    // 打印矩阵 C
    printf("C = \n");
    for (int i = 0; i < C.n; i++) {
        printf("%d %d %d\n", C.data[i].row, C.data[i].col, C.data[i].value);
    }
    // 释放内存
    free(A.data);
    free(B.data);
    free(C.data);
}

运行该测试函数，输出结果如下：

C = 
1 1 -1
1 2 3
2 1 4

可以看到，输出的矩阵 C 的元素值的确是矩阵 A 减去矩阵 B 的结果。