转置三元组中的稀疏矩阵

     先介绍个概念，什么叫做三元组，把稀疏矩阵用链表形式存储起来，目的是压缩稀疏矩阵的空间，节省内存。

数据结构如下：

#define MAXSIZE 12500  //假设非零元个数的最大值为12500

typedef struct{


int i,j;

//该非零元的行下标和列下标
ElemType e;

}Triple;



typedef struct{


Triple data[MAXSIZE+1];

//非零元三元组表，data[0]未用
int mu,nu,tu;

//矩阵的行数、列数和非零元个数
}TSMatrix;

下面我们讨论下怎样转置这样的矩阵，有一种最简单的运算，对于m*n的矩阵M,它的转置矩阵T是n*m的矩阵，且T(i,j)=M(j,i),1<=i<=n，1<=j<=m。
　　显然一个稀疏矩阵的转置矩阵仍然是稀疏矩阵，假设变量a和b是TSMatrix类型，分别表示矩阵M和T，那么如何由a倒b呢?

上一段算法：

Status TransposeSMatrix(TSMatrix M,TSMatrix &T)

{

//采用三元组表存储表示，求稀疏矩阵M的转置矩阵T

T.mu=M.nu; T.nu=M.mu; T.tu=M.tu;

if(T.tu)

{

q=1;

for(col=1;col<=M.nu;++col)

for(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=Mdata[p].e

    ++q;

}

}

return OK;

}

分析这个算法，主要是工作时在p和col的两重循环中完成的，故算法的时间复杂度为O(nu*tu),M的列数及非零元的个数的乘积成正比。
我们知道一般的矩阵转置算法为

　　　　for(col=1;col<=nu;++col)

　　　　　　for(row=1;row<=mu;++row)

　　　　　　　　T[col][row]=M[row][col];

它的时间复杂度为O(mu*nu)。当非零元的个数tu和mu*nu同数量级时，算法O(nu*tu)的时间复杂度就为O(mu*nu²)了，虽然节省了空间，但是时间复杂度提高了，所以只是用于tu<<mu*nu的情况。

 

下面我们对上面的算法进行改进，提前将M转向T之后的位置序号算出

Status FastTranSposeSmatrix(TSMatrix M,TSMatrix &T)

{

      T.mu=M.nu;T.nu=M.mu;T.tu=M.tu;

 if(T.tu)

{

 for(col=1;col<=M.nu;++col) mun[col]=0;

for(t=1;t<=M.tu;++t) ++num[M.data[t].j];//求出M中每一列含有非零元个数

cpot[1]=1;

//求第col列中地一个非零元在b.data中的序列号

for(col=2;col<=M.nu;++col) cpot[col]=cpot[col-1]+num[col-1];

for(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=Mdata[p].;

    ++cpot[col];

}

}

return OK;

}

该进后的算法非常帅气将时间复杂度优化到了O(nu+tu)
当tu和mu*nu数量级相等时，其时间复杂度为O(mu*nu)和经典算法复杂度相同。