数据结构(C语言描述)读书笔记之稀疏矩阵

     稀疏矩阵是指非零元素的个数远远小于零元素的个数。稀疏矩阵的存储结构包括顺序存储和链接存储结构。

    顺序存储:

    struct Triple{

          int row,col;

          ElemType val;

     }

     struct SMatrix{

          int m,n,t;

          struct Triple sm[MaxTerms+1];

     }

     m,n,t分别用来存储稀疏矩阵的行数，列数和非零元素的个数

     带行指针向量的链接存储

     struct TripleNode{

          int row,col;

          ElemType val;

          struct TripleNode* next;

     }

     struct LMartix{

          int m,n,t;

          struct TripleNode* lm[MaxRow+1];

     }

     lm存储每一行的表头指针。

     struct CrossNode{

          int row,col;

          ElemType val;

          struct CrossNode *down,*right;

     }

     struct CLMatrix{

          int m,n,t;

          struct CrossNode* rm[MaxRows+1];

          struct CrossNode* cm[MaxColumns+1];

     }

     

     初始化运算:

     void InitMatrix1(struct SMartix* M)

     {

          M->m=0;M->n=0;M->t=0;

     }

     void InitMartix2(struct LMartix* M)

     {

           int i;

            M->m=0;M->n=0;M->t=0;

          for(i=1;i<=MaxRows;i++)

               M->lm[i]=NULL;

     }

     void InitMartix3(struct CLMartix* M)

     {

          int i;

          M->m=0;M->n=0;M->t=0;

          for(i=1;i<MaxRows;i++)

               M->rm[i]=NULL;

          for(i=1;i<MaxColumns;i++)

               M->cm[i]=NULL;

     }

     

     稀疏矩阵的建立

     void InputMatrix1(struct SMatrix* M, int m, int n)

     {

          int k=0;

          int row,col;

          ElemType val;

          M->m=m;M->n=n;

          printf("input triple:\n");

          scanf("%d %d %d",&row,&col,&val);

          while(row!=0){

               k++;

               M->sm[k].row=row;

               M->sm[k].col=col;

               M->sm[k].val=val;

               scanf("%d %d %d",&row,&col,&val);

          }

          M->t=k;

     }

     void InputMatrix2(struct LMatrix* M,int m,int n)

     {

          int k=0;

          int row,col;

          ElemType val;

          M->m=m;M->n=n;

          printf("input triple:\n");

          scanf("%d %d %d",&row,&col,&val);

          while(row!=0){

               k++;

               struct TripleNode *cp,* newp;

               newp=malloc(sizeof(struct TripleNode));

               newp->row=row;

               newp->col=col;

               newp->val=val;

               newp->next=NULL;

               cp=M->lm[row];

               if(cp==NULL)M->lm[row]=newp;

               else{

                        while(cp->next!=NULL)

                              cp=cp->next;

                         cp->next=t;

               }

               scanf(%d %d %d",&row,&col,&val);

           }

           M->t=k;

     }

     void InputMatrix3(struct CLMartix* M,int m,int n)

     {

          int k=0;

          int row,col;

          ElemType val;

          M->m=m;M->n=n;

          printf("Input triple:\n");

          scanf("%d %d %d",&row,&col,&val);

          while(row!=0){

               struct CrossNode *cp,*newp;

               k++;

               newp=malloc(sizeof(struct CrossNode));

               newp->row=row;

               newp->col=col;

               newp->val=val;

               newp->down=newp->right=NULL;

               cp=M->rm[row];

               if(cp==NULL)

                    M->rm[row]=newp;

               else{

                    while(cp->right!=NULL)

                         cp=cp->right;

                    cp->right=newp;

               }

               cp=M->cm[row];

               if(cp==NULL)

                    M->cm[col]=newp;

               else{

                    while(cp->down!=NULL)

                         cp=cp->down;

                    cp->down=newp;

               }

               scanf("%d %d %d",&row,&col,&val);

          }

          M->t=k;

     }

     

     稀疏矩阵的输出:

     void OutputMatrix1(struct SMatrix* M)

     {

          int i;

          printf("(");

          for(i=1;i<M->t;i++){

               printf("(%d %d %d)," M->sm[i].row,M->sm[i].col,M->sm[i].val);

          }

          if(M->t!=0){

               printf("(%d %d %d)",M->sm[i].row,M->sm[i].col,M->sm[i].val);

          }

          printf(")\n");

     }

     void OutputMartix2(struct LMartix* M)

     {

          int i;

          struct TripleNode *p;

          printf("(");

          for(i=1;i<M->m;i++){

               for(p=M->lm[i];p!=NULL;p=p->next)

                    printf("(%d %d %d),",p->row,p->col,p->val);

          }

          printf(")\n");

     }

     void OutputMartix3(struct CLMartix* M)

     {

          int i;

          struct CrossNode *p;

          printf("(");

          for(i=1;i<M->m;i++){

               for(p=M->rm[i];p!=NULL;p=p->right)

                    printf("%d %d %d)",p->row,p->col,p->val);

          }

          printf(")\n");

     }

     矩阵转置

     struct SMartix* TransposeMatrix(struct SMatrix* M)

     {

          int m,n,t;

          int k,i,col;

          struct SMatrix* S;

          S=malloc(sizeof(struct SMatrix));

          InitMatrix(S);

          m=M->m;n=M->n;t=M->t;

          S->m=n;S->n=m;S->t=t;

          if(t==0) return S;

          k=1;

          for(col=1;col<=n;col++){

               for(i=1;i<=t;i++)

                    if(M->sm[i].col==col){

                         S->sm[k].row=col;

                         S->sm[k].col=M->sm[i].row;

                         S->sm[k].val=M->sm[i].val;

                         k++;

                    }

          }

          return S;

     }

     稀疏矩阵的加法运算：

     struct LMatrix* AddMatrix(struct LMatrix* M1,struct LMatrix* M2)

     {

          int k,i;

          struct LMatrix* M;

          M=malloc(sizeof(struct LMatrix));

          InitMatrix2(M);

          if((M1->m!=M2->m)||(M1->n!=M2->n)){

               printf("M1's size not equal M2's size!\");

               exit(1);

          }

          M->m=M1->m;M->n=M1->n;

          if(M1->t==0&&M2->t==0)

               return 0;

          k=0;

          for(i=1;i<M1->m;i++)

               struct TripleNode *p1,*p2,*p;

               p1=M1->lm[i];

               p2=M2->lm[i];

               p=M->lm[i];

               while((p1!=NULL)&&(p2!=NULL)){

                    struct TripleNode *newp;

                    newp=malloc(sizeof(struct TripleNode));

                    if(p1->col<p2->col){

                         *newp=*p1;

                         p1=p1->next;

                    }

                    else if(p1->col>p2->col){

                         *newp=*p2;

                         p2=p2->next;

                    }

                    else{

                         if(p1->val+p2->val==0){

                              p1=p1->next;p2=p2->next;

                              free(newp);

                              continue;

                         }

                         else{

                              *newp=*p1;

                              newp->val+=p2->val;

                              p1=p1->next;p2=p2->next;

                         }

                     }

                     newp->next=NULL;

                     if(p==NULL)M->lm[i]=newp;

                     else p->next=newp;

                     p=newp;

                     k++;

               }

               while(p1!=NULL){

                    struct TripleNode* newp;

                    newp=malloc(sizeof(struct TripleNode));

                    *newp=*p1;

                    newp->next=NULL;

                    if(p==NULL)M->lm[i]=newp;

                    else p->next=newp;

                    p=newp;

                    p1=p1->next;

                    k++;

             }

               while(p2!=NULL){

                    struct TripleNode* newp;

                    newp=malloc(sizeof(struct TripleNode));

                    *newp=*p2;

                    newp->next=NULL;

                    if(p==NULL) M->lm[i]=newp;

                    else p->next=newp;

                    p=newp;

                    p2=p2->next;

                    k++;

               }

          }

          M->t=k;

          return M;

     }