转置三元组中的稀疏矩阵

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

数据结构如下：

#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)和经典算法复杂度相同。