稀疏矩阵运算器
基本要求
以＂带行逻辑链接信息“的三元组顺序表示稀疏矩阵，实现两个矩阵相加、相减和相乘的运算。稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则以通常的阵列形式列出。

 
   /*(程序名) */
 #include<string.h>
 #include<ctype.h>
 #include<malloc.h> 
 #include<limits.h> 
 #include<stdio.h> 
 #include<stdlib.h> 
 #include<io.h> 
 #include<math.h> 
 #include<process.h> 
 /* 函数结果状态代码 */
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define INFEASIBLE -1
 
 typedef int Status; 
 typedef int Boolean; 
 typedef int ElemType;
  
 #define MAXSIZE 100 
 #define MAXRC 20 
 typedef struct
 {
   int i,j; 
   ElemType e; 
 }Triple;
 typedef struct
 {
   Triple data[MAXSIZE+1]; 
   int rpos[MAXRC+1]; 
   int mu,nu,tu; 
 }RLSMatrix;

  
 Status CreateSMatrix(RLSMatrix *M)
 { 
   int i;
   Triple T;
   Status k;
   printf("请输入矩阵的行数,列数,非零元素数：");
   scanf("%d,%d,%d",&(*M).mu,&(*M).nu,&(*M).tu);
   (*M).data[0].i=0; 
   for(i=1;i<=(*M).tu;i++)
   {
     do
     {
       printf("请按行序顺序输入第%d个非零元素所在的行(1～%d),列(1～%d),元素值：",i,(*M).mu,(*M).nu);
       scanf("%d,%d,%d",&T.i,&T.j,&T.e);
       k=0;
       if(T.i<1||T.i>(*M).mu||T.j<1||T.j>(*M).nu) 
         k=1;
       if(T.i<(*M).data[i-1].i||T.i==(*M).data[i-1].i&&T.j<=(*M).data[i-1].j) 
         k=1;
     }while(k); 
     (*M).data[i]=T;
   }
   for(i=1;i<=(*M).tu;i++) /* 计算rpos[] */
     if((*M).data[i].i>(*M).data[i-1].i)
       for(T.i=0;T.i<(*M).data[i].i-(*M).data[i-1].i;T.i++)
         (*M).rpos[(*M).data[i].i-T.i]=i;
   for(i=(*M).data[(*M).tu].i+1;i<=(*M).mu;i++) 
     (*M).rpos[i]=(*M).tu+1;
   return OK;
 }

 void DestroySMatrix(RLSMatrix *M)
 { 
   (*M).mu=0;
   (*M).nu=0;
   (*M).tu=0;
 }

 void PrintSMatrix(RLSMatrix M)
 { 
   int i;
   printf("%d行%d列%d个非零元素。\n",M.mu,M.nu,M.tu);
   printf("行  列  元素值\n");
   for(i=1;i<=M.tu;i++)
     printf("%2d%4d%8d\n",M.data[i].i,M.data[i].j,M.data[i].e);
   for(i=1;i<=M.mu;i++)
     printf("第%d行的第一个非零元素是本矩阵第%d个元素\n",i,M.rpos[i]);
 }

 Status CopySMatrix(RLSMatrix M,RLSMatrix *T)
 { 
   *T=M;
   return OK;
 }

 Status AddSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix *Q)
 { 
   int k,p,q;
   if(M.mu!=N.mu||M.nu!=N.nu)
     return ERROR;
   (*Q).mu=M.mu;
   (*Q).nu=M.nu;
   (*Q).tu=0;
   M.rpos[M.mu+1]=M.tu+1; 
   N.rpos[N.mu+1]=N.tu+1;
   for(k=1;k<=M.mu;++k) 
   {
     (*Q).rpos[k]=(*Q).tu+1;
     p=M.rpos[k]; 
     q=N.rpos[k]; 
     while(p<M.rpos[k+1]&&q<N.rpos[k+1])
     { 
       if(M.data[p].j==N.data[q].j) 
       {
         (*Q).data[(*Q).tu+1].e=M.data[p].e+N.data[q].e;
         if((*Q).data[(*Q).tu+1].e!=0)
         {
           ++(*Q).tu;
           (*Q).data[(*Q).tu].i=k;
           (*Q).data[(*Q).tu].j=M.data[p].j;
         }
         ++p;
         ++q;
       }
       else if(M.data[p].j<N.data[q].j)
       { 
         ++(*Q).tu;
         (*Q).data[(*Q).tu].e=M.data[p].e;
         (*Q).data[(*Q).tu].i=k;
         (*Q).data[(*Q).tu].j=M.data[p].j;
         ++p;
       }
       else 
       {
         ++(*Q).tu;
         (*Q).data[(*Q).tu].e=N.data[q].e;
         (*Q).data[(*Q).tu].i=k;
         (*Q).data[(*Q).tu].j=N.data[q].j;
         ++q;
       }
     }
     while(p<M.rpos[k+1]) 
     {
       ++(*Q).tu;
       (*Q).data[(*Q).tu].e=M.data[p].e;
       (*Q).data[(*Q).tu].i=k;
       (*Q).data[(*Q).tu].j=M.data[p].j;
       ++p;
     }
     while(q<N.rpos[k+1]) 
     {
       ++(*Q).tu;
       (*Q).data[(*Q).tu].e=N.data[q].e;
       (*Q).data[(*Q).tu].i=k;
       (*Q).data[(*Q).tu].j=N.data[q].j;
       ++q;
     }
   }
   return OK;
 }