三元组表(稀疏矩阵的三元组表示及)

三元组表是一种常用的数据结构，用来描述实体之间的关系。在本篇文章中，我们将从多个方面分析三元组表，以便更好地理解和应用这个数据结构。

一、三元组表的定义

三元组表是由三个元素组成的表，每个元素可以是值、变量或表达式。

    // 三元组表的定义
    typedef struct {
        ElemType r0, r1, r2;
    } Triple;
    typedef struct {
        Triple *data;  // 存储三元组表的数组指针
        int mu, nu, tu;  // mu表示行数，nu表示列数，tu表示非零元素个数
    } TSMatrix;

其中，Triple表示每个元素的结构体，包括三个值，分别为r0、r1和r2。TSMatrix表示三元组表的结构体，包括data、mu、nu和tu四个值。

通过三元组表，我们可以更好地描述稀疏矩阵，尤其适用于压缩存储，减少空间浪费。

二、三元组表的初始化

三元组表的初始化包括创建和销毁两个部分。

创建三元组表：

    // 创建三元组表
    int CreateSMatrix_TS(TSMatrix *M) {
        printf("请输入矩阵行数、列数、非零元素个数：");
        scanf("%d,%d,%d", &M->mu, &M->nu, &M->tu);
        if (M->tu > MAXSIZE) return 1;  // 非零元素个数超过限制值，返回错误
        M->data = (Triple *)malloc((M->tu+1)*sizeof(Triple));  // 申请指定大小的内存空间
        if (!M->data) return 1;  // 内存申请失败，返回错误
        for (int t=1; ttu; t++) {
            printf("请输入第%d个非零元素的行、列、值：", t);
            scanf("%d,%d,%d", &M->data[t].r0, &M->data[t].r1, &M->data[t].r2);
        }
        return 0;  // 返回成功
    }

销毁三元组表：

    // 销毁三元组表
    void DestroySMatrix_TS(TSMatrix *M) {
        free(M->data);
        M->data = NULL;
        M->mu = M->nu = M->tu = 0;
    }

三、三元组表的转置

三元组表的转置是指将矩阵的行列对换，得到新的矩阵。

    // 三元组表的转置
    int TransposeSMatrix_TS(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; pdata[q].r0 = M.data[p].r1;
                        T->data[q].r1 = M.data[p].r0;
                        T->data[q].r2 = M.data[p].r2;
                        q++;
                    }
                }
            }
        }
        return 0;
    }

四、三元组表的加法

三元组表的加法是对两个矩阵的对应元素进行相加。

    // 三元组表的加法
    int AddSMatrix_TS(TSMatrix M1, TSMatrix M2, TSMatrix *M3) {
        if (M1.mu != M2.mu || M1.nu != M2.nu) return 1;  // 判断两个矩阵是否相同
        M3->mu = M1.mu;
        M3->nu = M1.nu;
        int i=1, j=1, k=0;
        while (i<=M1.tu && j<=M2.tu) {
            if (M1.data[i].r0 data[k].r0 = M1.data[i].r0;
                M3->data[k].r1 = M1.data[i].r1;
                M3->data[k].r2 = M1.data[i].r2;
                k++; i++;
            } else if (M1.data[i].r0 > M2.data[j].r0) {
                // 如果行号大于，将M2当前元素加入到结果矩阵中
                M3->data[k].r0 = M2.data[j].r0;
                M3->data[k].r1 = M2.data[j].r1;
                M3->data[k].r2 = M2.data[j].r2;
                k++; j++;
            } else {
                if (M1.data[i].r1 data[k].r0 = M1.data[i].r0;
                    M3->data[k].r1 = M1.data[i].r1;
                    M3->data[k].r2 = M1.data[i].r2;
                    k++; i++;
                } else if (M1.data[i].r1 > M2.data[j].r1) {
                    // 如果行号相等但列号大于，将M2当前元素加入到结果矩阵中
                    M3->data[k].r0 = M2.data[j].r0;
                    M3->data[k].r1 = M2.data[j].r1;
                    M3->data[k].r2 = M2.data[j].r2;
                    k++; j++;
                } else {
                    // 如果行号列号都相等，将两个元素相加，并将结果添加到结果矩阵中
                    M3->data[k].r0 = M1.data[i].r0;
                    M3->data[k].r1 = M1.data[i].r1;
                    M3->data[k].r2 = M1.data[i].r2 + M2.data[j].r2;
                    if (M3->data[k].r2 != 0) k++;  // 如果结果不为0，计数器自增
                    i++; j++;
                }
            }
        }
        while (i data[k].r0 = M1.data[i].r0;
            M3->data[k].r1 = M1.data[i].r1;
            M3->data[k].r2 = M1.data[i].r2;
            k++; i++;
        }
        while (j data[k].r0 = M2.data[j].r0;
            M3->data[k].r1 = M2.data[j].r1;
            M3->data[k].r2 = M2.data[j].r2;
            k++; j++;
        }
        M3->tu = k;  // 矩阵行列式存储
        return 0;
    }

五、总结

本篇文章介绍了三元组表数据结构的定义、初始化、转置和加法等操作，并给出了对应的代码示例。三元组表是一种常用的数据结构，适用于存储稀疏矩阵，在节省存储空间方面有很大的优势。希望这篇文章能够帮助读者更好地理解和运用三元组表。