矩阵转置+矩阵相加（三元组）

稀疏矩阵

如果在矩阵中，多数的元素为0，通常认为非零元素比上矩阵所有元素的值小于等于0.05时，则称此矩阵为稀疏矩阵（sparse matrix）。

• 基本结构

//---------稀疏矩阵基本结构----------
typedef struct
{
    int i, j;
    ElemType elem;
}Triple;

typedef struct
{
    Triple data[MaxSize];
    int mu,nu,tu;
}TSMatrix;

• 矩阵转置O(n²)

//矩阵转置O(n²)
void TransposeMatrix1(TSMatrix M,TSMatrix *T)
{
    int p, q, col;
    T->mu = M.mu, T->nu = M.nu, T->tu = M.tu;
    if(T->tu > 0)   //非空矩阵
    {
        q = 0;
        for(col = 0; col < T->nu; col++)        //枚举每一个列
            for(p = 0; p < T->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].elem = M.data[p].elem;
                q++;
            }
    }
}

• 举证转置O(n)
  

  原理：如果能预先确定矩阵M中每一列（即T中的每一行）的第一个非零元素在T中的合适位置，那么在对M进行转置时就可以直接放到T中的恰当位置上去。为了确定这些位置，应先求得M的每一列中非零元的个数，进而求得每一列的第一个非零元在T中的位置。
  
  设num[]和cpot[]分别用来存放每一列的非零元的个数和该列第一个非零元在转置后矩阵T中的位置。则显然有：
  
  cpot[0]= 0;
cpot[col] = cpot[col-1]+num[col-1] 0<=col<M.nu
  
  而每一列的非零元的个数可以通过对整个矩阵M扫描一遍得到。

//举证转置O(n)
void TransposeMatrix2(TSMatrix M, TSMatrix *T)
{
    T->mu = M.mu, T->nu = M.nu, T->tu = M.tu;
    int num[1000], cpot[1000], p;
    if(T->tu > 0)
    {
        for(p = 0; p < M.tu; p++)           //初始化每一列的非零元的个数num
            num[p] = 0, cpot[p] = 0;        //该列第一个非零元在转置后矩阵T中的位置cpot
        for(p = 0; p < M.tu; p++)           //统计每列的非零元个数 
            num[M.data[p].j]++;
        for(p = 1; p < M.tu; p++)           //计算每列第一个非零元转置后的位置
            cpot[p] = cpot[p-1]+num[p-1];

        for(int q = 0; q < M.tu; q++)
        {
            int t = M.data[q].j;
            int p = cpot[t];
            T->data[p].i = M.data[q].j;
            T->data[p].j = M.data[q].i;
            T->data[p].elem = M.data[q].elem;
            cpot[t]++;                     //该列的下个元素放在下一个位子
        }
    }
}

• 矩阵加法

int cmp(Triple m1, Triple m2)
{
    if(m1.i == m2.i)
    {
        if(m1.j == m2.j)
            return 0;
        else if(m1.j < m2.j)
            return -1;
        else
            return 1;
    }
    else if(m1.i < m2.i)
        return -1;
    else
        return 1;
}
void MatrixAdd(TSMatrix *m1, TSMatrix *m2, TSMatrix *m3)
{
    int p = 0, q = 0;
    int k = 0;
    while(p < m1->tu && q < m2->tu)            //思路同归并
    {
        if(cmp(m1->data[p], m2->data[q]) == -1)
        {
            m3->data[k].i = m1->data[p].i;
            m3->data[k].j = m1->data[p].j;
            m3->data[k].elem = m1->data[p].elem;
            k++;
            p++;
        }
        else if(cmp(m1->data[p], m2->data[q]) == 1)
        {
            m3->data[k].i = m2->data[q].i;
            m3->data[k].j = m2->data[q].j;
            m3->data[k].elem = m2->data[q].elem;
            k++;
            q++;
        }
        else
        {
            m3->data[k].i = m2->data[q].i;
            m3->data[k].j = m2->data[q].j;
            m3->data[k].elem = m1->data[p].elem+m2->data[q].elem;
            k++;
            q++, p++;
        }
    }
    while(p < m1->tu)
    {
        m3->data[k].i = m1->data[p].i;
        m3->data[k].j = m1->data[p].j;
        m3->data[k].elem = m1->data[p].elem;
        k++;
        p++;
    }
    while(q < m2->tu)
    {
        m3->data[k].i = m2->data[q].i;
        m3->data[k].j = m2->data[q].j;
        m3->data[k].elem = m2->data[q].elem;
        k++;
        q++;
    }
    m3->tu = k;
}