稀疏矩阵的三元组顺序存储

该数据结构的操作主要是数组的相加 和相乘，这两个算法全是我个人所写，绝无参考，经测试应该少有bug

“a.h”

#include

#define FALSE 0
#define TRUE 1
#define OK 1
#define ERROR 0
#define MAX_SIZE 100

typedef int ElemType;
typedef int Status;
typedef struct{
   int i,j;    //坐标
   ElemType e;     //非零元素值
}Triple;
typedef struct{
   Triple data[MAX_SIZE];
   int mu,nu,tu;      //行数，列数，非零元个数
}Matrix;

 

“b.h”

Status CreateMatrix(Matrix *M)
{
    int i,m,n,k;
       ElemType e;
    printf("输入数组的行数，列数，非零元个数 ");
    scanf("%d %d %d",&(*M).mu,&(*M).nu,&(*M).tu);
    for(i=0;i<(*M).tu;i++){
     do{
      printf("输入第%d个元素的行坐标，列坐标，元素值",i+1);
      scanf("%d %d %d",&m,&n,&e);
      k=0;
      if(m<1||n<1||m>(*M).mu||n>(*M).nu){
       k=1;
       printf("输入错误，重新输入\n");
      }
     }while(k);
      (*M).data[i].i=m;
      (*M).data[i].j=n;
      (*M).data[i].e=e;
    }
   return OK;
}

Status MatrixDestroy(Matrix M)
{
     M.mu=0;
  M.nu=0;
  M.tu=0;
  return OK;
}

Status MatrixPrint(Matrix M)
{
 int i;
    printf("行数;%d 列数: %d总数: %d\n",M.mu,M.nu,M.tu);
 printf("行坐标  列坐标  值\n");
 for(i=0;i
    printf("%d     %d     %d\n",M.data[i].i,M.data[i].j,M.data[i].e);
    return OK;
}

Status MatrixCopy(Matrix M1,Matrix *M2)
{
     (*M2)=M1;
  return OK;
}
Status AssignData(Triple *data,ElemType e,int m,int n)
{
    (*data).e=e;
 (*data).i=m;
 (*data).j=n;
 return OK;
}

Status AddMatrix(Matrix A,Matrix B,Matrix *C) 
{
    int i=0,j=0,k=0,x=0,X[MAX_SIZE];
    Triple m,n;
       if(A.mu!=B.mu||A.nu!=B.nu)
     return ERROR;
       (*C).mu=B.mu;
    (*C).nu=B.nu;
    while(i
         m=A.data[i];
      i++;
   while(j
     n=B.data[j]; 
     if(m.i==n.i&&m.j==n.j){
                  X[++x]=j;
      break;
     }
     j++;
   } 
   if(j
      AssignData(&(*C).data[k++],m.e+n.e,m.i,m.j);        //A B元素坐标相同的相加
   else
               AssignData(&(*C).data[k++],m.e,m.i,m.j);           //A中有B中无的元素进行直接赋值
        j=0;                //care
    }
    //以下代码是为了将B中有A中无的三元组赋值   我们先用数组（可用指针节约空间）记录A,B中都有的元素，然后除去这些三元组就是需要的
         X[0]=0;
   if(X[1]!=0)
       for(j=0;j
     n=B.data[j];
        AssignData(&(*C).data[k++],n.e,n.i,n.j);          //考虑X[1]
   }
   for(i=0;i
      for(j=1;j
     n=B.data[X[i]+j];
     AssignData(&(*C).data[k++],n.e,n.i,n.j);
      }
   if(X[x]
    for(j=X[x]+1;j<=B.tu;j++){
     n=B.data[j-1];
        AssignData(&(*C).data[k++],n.e,n.i,n.j);
    }
       (*C).tu=A.tu+B.tu-x;
       return OK;
}

Status SubMatrix(Matrix A,Matrix B,Matrix *C)
{
        int i;
  for(i=0;i
   B.data[i].e*=(-1);
  AddMatrix(A,B,C);
  return OK;
}

Status MulMatrix(Matrix A, Matrix B,Matrix *C)
{
       int i=0,j=0,k=0,x=0;
    Triple m,n,X[MAX_SIZE];
       if(A.nu!=B.mu)
     return ERROR;
       (*C).mu=A.mu;
    (*C).nu=B.nu;
    while(i
         m=A.data[i];
      i++;
   while(j
     n=B.data[j];
     if(n.i==m.j)
    AssignData(&X[k++],m.e*n.e,m.i,n.j);   //我们先用一个数组X(可用malloc分配)记录所有的n.j和m.i相同的三元组的乘积
     j++;
    }
   j=0;
    }  
    //     以下算法将X中坐标相同的元素进行累加即为（*C）的该坐标值
    for(i=0;i
       (*C).data[0]=X[0];
    for(i=1;i
     for(j=0;j<=x;j++){
             if(X[i].i==(*C).data[j].i&&X[i].j==(*C).data[j].j){
     (*C).data[j].e+=X[i].e;
    break;
      }
     }
     if(j>x)
   (*C).data[++x]=X[i];          //care 是++x传进去
    }
  (*C).tu=x+1;
  return OK;
}

 

“main.h”

#include"a.h"
#include"b.h"
void main()
{
   Matrix M,N,L;
   CreateMatrix(&M);
   MatrixPrint(M);
   CreateMatrix(&N);
   MatrixPrint(N);
   MulMatrix(M,N,&L);
   printf("***************MUL*********************\n");
    MatrixPrint(L);
 MatrixDestroy(L);
   AddMatrix(M,N,&L);
    printf("***************ADD********************\n");
   MatrixPrint(L);
}