(数据结构第五章)稀疏矩阵三元顺序表存储

///以顺序存储结构来表示三元组表，则可得稀疏矩阵的一种压缩存储方式
///三元组顺序表
///*************稀疏矩阵的三元组顺序存储表示***************
#include<cstdio>
#include<algorithm>
using namespace std;
#define MAXSIZE 12500   /// 假设非零元个数最大值为12500
#define OK 1
typedef struct {
    int     i,j;        ///  该非零元的行下标和列下标
    int    e;
}Triple;
typedef struct {
    Triple data[MAXSIZE + 1];   /// 非零元三元组表，data[0]未用
    int     mu,nu,tu;           /// 矩阵的行数、列数和非零元个数
}TSMatrix;
void ScanfSMatrix(TSMatrix &M){
    int x=0,k=1;
    M.tu = 0;
    for(int i=1;i<=M.mu;i++){
        for(int j=1;j<=M.nu;j++){
            scanf("%d",&x);
            if(x!=0){
                M.data[k].e = x;
                M.data[k].i=i;
                M.data[k].j=j;
                k++;
                M.tu++;
            }
        }
    }
}
void PrintfSMatrix(TSMatrix M){
    printf("当前矩阵为：\n");
    int k=1;
    for(int i=1;i<=M.mu;i++){
        for(int j=1;j<=M.nu;j++){
            if(M.data[k].i==i &&M.data[k].j==j ){
                printf("%3d",M.data[k].e);
                k++;
            }
            else printf("%3d",0);
        }
        puts("");
    }
    return ;
}
int TransposeSMatrix(TSMatrix M, TSMatrix & T){
    ///采用三元组表存储表示，求稀疏矩阵M的转置矩阵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; 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;
            }
    }
    return OK;
}///TransposeSMatrix
///算法时间复杂度O(mu*nu)
///只适用于tu<<mu*nu的情况
int num[MAXSIZE + 1],cpot[MAXSIZE + 1];
int FastTransposeSMatrix(TSMatrix M,TSMatrix &T){
    ///采用三元组顺序表存储表示，求稀疏矩阵M的转置矩阵T
    T.mu = M.nu;    T.nu = M.mu;    T.tu=M.tu;
    if(T.tu){
        for(int col=1;col<=M.nu;++col)  num[col]=0; ///清零
        for(int t=1;t<=M.tu;++t) ++num[M.data[t].j];    ///求M中每一列含非零个数
        cpot[1]=1;
        /// 求第col列中第一个非零元在b.data中的序号
        for(int col =2; col <= M.nu; ++col) cpot[col] = cpot[col - 1] + num[col - 1];
        for(int p = 1; p <= M.tu; ++p){
            int col = M.data[p].j;      int 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
    return OK;
}///FastTransposeSMatrix
///此算法为快速转置算法
///总时间复杂度为O(nu+tu)
///而在tu和mu*nu等数量级时，时间复杂度O(mu*nu) 和经典算法时间复杂度相同
int main()
{
    TSMatrix M;     ///定义一个三元顺序表存储矩阵M
    printf("请输入稀疏矩阵行n和列m:");
    scanf("%d%d",&M.mu,&M.nu);
    ScanfSMatrix(M);
    PrintfSMatrix(M);

    ///测试TransposeSMatrix
    TSMatrix T;
    TransposeSMatrix(M, T);
    PrintfSMatrix(T);

    ///测试FastTransposeSMatrix
    FastTransposeSMatrix(M, T);
    PrintfSMatrix(T);
    return 0;
}