请编写c程序,实现一个能进行稀疏矩阵基本运算的运算器。三元矩阵形式

实现稀疏矩阵基本运算的运算器需要对三元矩阵进行处理。

三元矩阵结构体定义：

typedef struct{
    int row;    // 行
    int col;    // 列
    int value;  // 值
}TriTupleNode;
typedef struct {
    TriTupleNode data[MAX_SIZE];    // 三元组顺序存储结构体
    int mu, nu, tu; // 行数、列数、非零元素个数
}TSMatrix;

实现的基本运算包括：矩阵加法、矩阵减法和矩阵乘法。

1. 稀疏矩阵加法

int AddTSMatrix(TSMatrix A, TSMatrix B, TSMatrix *C){
    if (A.mu != B.mu || A.nu != B.nu)
        return 0;   // 两矩阵行数不相等或列数不相等，不能加减
    C->mu = A.mu;
    C->nu = A.nu;
    int k = 0, i = 0, j = 0;
    while (i < A.tu && j < B.tu){
        if (A.data[i].row < B.data[j].row){
            C->data[k++] = A.data[i++];
        } else if (A.data[i].row > B.data[j].row){
            C->data[k++] = B.data[j++];
        } else {
            if (A.data[i].col < B.data[j].col){
                C->data[k++] = A.data[i++];
            } else if (A.data[i].col > B.data[j].col){
                C->data[k++] = B.data[j++];
            } else {
                int sum = A.data[i++].value + B.data[j++].value;
                if (sum != 0){
                    C->data[k].row = A.data[i-1].row;
                    C->data[k].col = A.data[i-1].col;
                    C->data[k++].value = sum;
                }
            }
        }
    }
    while (i < A.tu)
        C->data[k++] = A.data[i++];
    while (j < B.tu)
        C->data[k++] = B.data[j++];
    C->tu = k;
    return 1;
}

2. 稀疏矩阵减法

int SubTSMatrix(TSMatrix A, TSMatrix B, TSMatrix *C){
    if (A.mu != B.mu || A.nu != B.nu)
        return 0;   // 两矩阵行数不相等或列数不相等，不能加减
    C->mu = A.mu;
    C->nu = A.nu;
    int k = 0, i = 0, j = 0;
    while (i < A.tu && j < B.tu){
        if (A.data[i].row < B.data[j].row){
            C->data[k++] = A.data[i++];
        } else if (A.data[i].row > B.data[j].row){
            C->data[k] = B.data[j++];
            C->data[k].value = -C->data[k].value;   // 值取负
            k++;
        } else {
            if (A.data[i].col < B.data[j].col){
                C->data[k++] = A.data[i++];
            } else if (A.data[i].col > B.data[j].col){
                C->data[k] = B.data[j++];
                C->data[k].value = -C->data[k].value;   // 值取负
                k++;
            } else {
                int sum = A.data[i++].value - B.data[j++].value;
                if (sum != 0){
                    C->data[k].row = A.data[i-1].row;
                    C->data[k].col = A.data[i-1].col;
                    C->data[k++].value = sum;
                }
            }
        }
    }
    while (i < A.tu)
        C->data[k++] = A.data[i++];
    while (j < B.tu){
        C->data[k] = B.data[j++];
        C->data[k].value = -C->data[k].value;   // 值取负
        k++;
    }
    C->tu = k;
    return 1;
}

3. 稀疏矩阵乘法

int MultTSMatrix(TSMatrix A, TSMatrix B, TSMatrix *C){
    if (A.nu != B.mu)
        return 0;   // 两矩阵行列数不匹配，不能相乘
    C->mu = A.mu;
    C->nu = B.nu;
    C->tu = 0;
    int *rows = (int *)malloc(sizeof(int) * (A.nu+1));
    memset(rows, -1, sizeof(int) * (A.nu+1));
    int *cols = (int *)malloc(sizeof(int) * (B.nu+1));
    memset(cols, -1, sizeof(int) * (B.nu+1));
    int k = 0;
    for (int i = 0; i < A.tu; i++){
        int col = A.data[i].col;
        for (int j = 0; j < B.tu; j++){
            int row = B.data[j].row;
            if (col == row){
                if (rows[col] == -1)
                    rows[col] = k;
                cols[row] = k;
                C->data[k].row = A.data[i].row;
                C->data[k].col = B.data[j].col;
                C->data[k++].value = A.data[i].value * B.data[j].value;
            }
        }
    }
    C->tu = k;
    int cnt[MAX_SIZE] = {0};
    for (int i = 0; i < A.nu; i++){
        if (rows[i] != -1){
            int head = rows[i];
            for (int j = head+1; j < C->tu; j++){
                if (C->data[j].row == C->data[head].row){
                    C->data[head].value += C->data[j].value;
                    C->data[j].value = 0;
                }
            }
        }
    }
    k = 0;
    for (int i = 0; i < B.nu; i++){
        if (cols[i] != -1){
            int head = cols[i];
            for (int j = head+1; j < C->tu; j++){
                if (C->data[j].col == C->data[head].col){
                    if (C->data[head].value == 0){
                        C->data[head] = C->data[j];
                        C->data[j].value = 0;
                    } else {
                        C->data[head].value += C->data[j].value;
                        C->data[j].value = 0;
                    }
                }
            }
            C->data[k++] = C->data[head];
        }
    }
    C->tu = k;
    free(rows);
    free(cols);
    return 1;
}

以上实现的是稀疏矩阵基本运算的运算器，可以满足对三元矩阵进行加减乘的操作。