稀疏矩阵-----三元组顺序表

最新推荐文章于 2024-01-09 20:23:25 发布

原创最新推荐文章于 2024-01-09 20:23:25 发布 · 2k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#稀疏矩阵 #数据结构

数据结构专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了稀疏矩阵三元组顺序表的转置算法，包括基本转置方法和改进算法，重点分析了两种方法的时间复杂度，并提供了改进算法的优化思路。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

三元组顺序表

它是稀疏矩阵的一种压缩存储方式。

稀疏矩阵的三元组顺序表的存储表示

    typedef struct
    {
        int  i,j;       //该非零元的行列表示
        ElemType e;     //该非零元的值
    }Triple;
    typedef struct
    {
        Triple data[MAXSIZE];
        int mu,nu,tu;    //对应行，列，非零元的个数
    }TSMatrix；

方法有两种：
普通

    void TransposeSMatrix(TSMatrix *M,TSMatrix *T)
    //T为转置后的三元组顺序表，M为转置前的三元组顺序表
    //这里不对data[0]作考虑，认为数组从1开始
    {
        int q;
        T->mu=M->nu;
        T->nu=M->mu;
        T->tu=M->tu;
        if(T->tu)   
        //确认矩阵中是否存在非零元
        {
            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;
                    }//if
        }//if
    }//TransposeSMatrix

算法的时间复杂度：O(nu*tu)；
如果tu==mu*nu,则时间复杂度为O(nu*nu*mu)；
由此该算法适用于tu*<<*nu*mu的情况;

改进后

    void FastTransposeSMatrix(TSMatrix *M,TSMatrix *T)
    //T为转置后的三元组顺序表，M为转置前的三元组顺序表
    //这里不对data[0]作考虑，认为数组从1开始
    {
        int q,col;
        int *cpot=(int *)malloc(sizeof(int)*(M->nu+1));
        //cpot[col]表示M中第col列中第一个非零元在矩阵中的恰当位置
        int *num=(int *)malloc(sizeof(int)*(M->nu+1));
        //num[col]表示矩阵M中第col列种非零元的个数
        T->mu=M->nu;
        T->nu=M->mu;
        T->tu=M->tu;
        if(T->tu)   
        //确认矩阵中是否存在非零元
        {
            for(col=1;col <= M->nu;++col)
            //清零
                num[col]=0;
            for(int t=1;t <= M->tu;++t)
            //赋值
                ++num[M->data[t].j];
            cpot[1]=1;
            for(col=2;col <= M->nu;++col)
            //对每一列中第一个非零元的位置赋值
                cpot[col] = cpot[col-1]+num[col-1];
            for(int p=1;p <= M->tu; ++p)
            //转置
            {
                col=M->data[p].j;
                q=cpot[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;
                ++cpot[col];
                //表示该列中不是第一个非零元的序号
            }//for
        }//if
    }//FastTransposeSMatrix