18、数据结构笔记之十八链表实现稀疏矩阵

18、数据结构笔记之十八链表实现稀疏矩阵

           “必须如蜜蜂一样，采过许多花，才能酿出蜜来。”

            上篇中实现了栈在多项式实现中的例子，再来看下稀疏矩阵通过链表方式实现。

           关键字：十字链表存储

1.  十字链表存储

           十字链表（OrthogonalList)是有向图的另一种链式存储结构。该结构可以看成是将有向图的邻接表和逆邻接表结合起来得到的。用十字链表来存储有向图，可以达到高效的存取效果。同时，代码的可读性也会得到提升。

为便于理解后续代码，从网上摘了如下内容：图1 ，用十字链表表示稀疏矩阵。

用十字链表表示稀疏矩阵的基本思想是：对每个非零元素存储为一个结点，结点由5个域组成，其结构如图2 表示，其中：row 域存储非零元素的行号，col 域存储非零元素的列号，v 域存储本元素的值，right，down 是两个指针域。

稀疏矩阵中每一行的非零元素结点按其列号从小到大顺序由right 域链成一个带表头结点的循环行链表，同样每一列中的非零元素按其行号从小到大顺序由down 域也链成一个带表头结点的循环列链表。即每个非零元素aij 既是第i 行循环链表中的一个结点，又是第j 列循环链表中的一个结点。行链表、列链表的头结点的row 域和col 域置0。每一列链表的表头结点的down 域指向该列链表的第一个元素结点，每一行链表的表头结点的right域指向该行表的第一个元素结点。由于各行、列链表头结点的row域、col域和v 域均为零，行链表头结点只用right指针域，列链表头结点只用right 指针域，故这两组表头结点可以合用，也就是说对于第i 行的链表和第i 列的链表可以共用同一个头结点。为了方便地找到每一行或每一列，将每行（列）的这些头结点们链接起来，因为头结点的值域空闲，所以用头结点的值域作为连接各头结点的链域，即第i 行（列）的头结点的值域指向第i+1行（列）的头结点，… ，形成一个循环表。这个循环表又有一个头结点，这就是最后的总头结点，指针HA 指向它。总头结点的row 和col 域存储原矩阵的行数和列数。
    因为非零元素结点的值域是datatype 类型，在表头结点中需要一个指针类型，为了使整个结构的结点一致，我们规定表头结点和其它结点有同样的结构，因此该域用一个联合来表示；改进后的结点结构如图3 所示。

 

 

2.  定义结构体

定义两个结构体OLNode和CrossList.

一个是节点，一个是头节点。

头结点中有两个指针分别是行链表头，列链表头。

 

typedefstructOLNode

{

           inti,j;   // 该非零元的行和列下标

           ElemTypee;   // 非零元素值

           structOLNode*right,*down;// 该非零元所在行表和列表的后继链域

}OLNode, *OLink;

typedefstruct//行和列链表头指针向量基址,由CreatSMatrix_OL()分配

{

           OLink*rhead, *chead;

           intmu, nu, tu;       //稀疏矩阵的行数、列数和非零元个数，手动输入

}CrossList;

 

3.  InitSMatrix

初始化CrossList变量

// 初始化M(CrossList类型的变量必须初始化,否则创建、复制矩阵将出错)

int InitSMatrix(CrossList *M)

{

           (*M).rhead=(*M).chead=NULL;

           (*M).mu=(*M).nu=(*M).tu=0;

           return1;

}

 

4.  CreateSMatrix

采用十字链表存储稀疏矩阵M。

如果该参数不为空，则先删除，调用DestorySMatrix函数。

输入矩阵的行数m、列数n和非零元个数t。

然后分配（m+1）行链表头，n+1个列标链表头。

初始化之。

然后输入t个元素，元素需要输入行列 值。

然后分配元素空间，创建一个OLNode节点。

接着将该点接入到对应行链表，列链表上。

// 创建稀疏矩阵M,采用十字链表存储表示。

int CreateSMatrix(CrossList *M)

{

           inti,j,k,m,n,t;

           ElemTypee;

           OLNode*p,*q;

           if((*M).rhead)

                     DestroySMatrix(M);

           printf("请输入稀疏矩阵的行数列数非零元个数:(space) ");

           scanf("%d%d%d",&m,&n,&t);

           (*M).mu=m;

           (*M).nu=n;

           (*M).tu=t;

           //初始化行链表头

           (*M).rhead=(OLink*)malloc((m+1)*sizeof(OLink));

           if(!(*M).rhead)

                     exit(0);

           //初始化列链表头

           (*M).chead=(OLink*)malloc((n+1)*sizeof(OLink));

           if(!(*M).chead)

                     exit(0);

           for(k=1;k<=m;k++)//初始化行头指针向量;各行链表为空链表

                     (*M).rhead[k]=NULL;

           for(k=1;k<=n;k++)//初始化列头指针向量;各列链表为空链表

                     (*M).chead[k]=NULL;

           printf("请按任意次序输入%d个非零元的行列元素值:（空格）\n",(*M).tu);

           for(k=0;k<t;k++)

           {

                     scanf("%d%d%d",&i,&j,&e);

                     p=(OLNode*)malloc(sizeof(OLNode));

                     if(!p)

                                exit(0);

                     p->i=i;//生成结点

                     p->j=j;

                     p->e=e;

                     if((*M).rhead[i]==NULL||(*M).rhead[i]->j>j)   

                     {

                                //p插在该行的第一个结点处

                                p->right=(*M).rhead[i];

                                (*M).rhead[i]=p;

                     }

                     else//寻查在行表中的插入位置

                     {

                                //从该行的行链表头开始，直到找到

                                for(q=(*M).rhead[i];q->right && q->right->j < j;q = q->right)

                                          ;

                                p->right=q->right;//完成行插入

                                q->right=p;

                     }

                     if((*M).chead[j]==NULL || (*M).chead[j]->i> i)

                     {

                                //p插在该列的第一个结点处

                                p->down= (*M).chead[j];

                                (*M).chead[j]= p;

                     }

                     else//寻查在列表中的插入位置

                     {

                                for(q= (*M).chead[j];q->down &&q->down->i < i;q = q->down)

                                          ;

                                p->down=q->down;//完成列插入

                                q->down=p;

                     }

           }

           return1;

}

 

 

5.  删除矩阵

销毁稀疏矩阵，传输参数是CrossList *M.

按行进行释放节点。然后释放头结点，分别释放头结点。

// 销毁稀疏矩阵M

int DestroySMatrix(CrossList *M)

{

           inti;

           OLNode*p,*q;

 

           for(i=1;i<=(*M).mu;i++)//按行释放结点

           {

                     p=*((*M).rhead+i);

                     while(p)

                     {

                                q=p;

                                p=p->right;

                                free(q);

                     }

           }

           free((*M).rhead);

           free((*M).chead);

           (*M).rhead=(*M).chead=NULL;

           (*M).mu=(*M).nu=(*M).tu=0;

           return1;

}

 

6.  输出矩阵PrintSMatrix

分别按行输出和按列输出，按行输出，就是一行一行遍历，反正每行都是串起来的，对不对？

按列输出同理。

 

// 按行或按列输出稀疏矩阵M

int PrintSMatrix(CrossListM)

{

           inti,j;

           OLinkp;

           printf("%d行%d列%d个非零元素\n",M.mu,M.nu,M.tu);

           printf("请输入选择(1.按行输出2.按列输出):");

           scanf("%d",&i);

           switch(i)

           {

           case1:

                     for(j=1;j<=M.mu;j++)

                     {

                                p=M.rhead[j];

                                while(p)

                                {

                                          printf("%d行%d列值为%d\n",p->i,p->j,p->e);

                                          p=p->right;

                                }

                     }

                     break;

           case 2:

                     for(j=1;j<=M.nu;j++)

                     {

                                p=M.chead[j];

                                while(p)

                                {

                                          printf("%d行%d列值为%d\n",p->i,p->j,p->e);

                                          p=p->down;

                                }

                     }

           }

           return1;

}

 

7.  复制矩阵

复制矩阵，从矩阵M复制到矩阵T。

 

int CopySMatrix(CrossListM,CrossList *T)

{

           inti;

           OLinkp,q,q1,q2;

 

           if((*T).rhead)

                     DestroySMatrix(T);

           (*T).mu=M.mu;

           (*T).nu=M.nu;

           (*T).tu=M.tu;

           (*T).rhead=(OLink*)malloc((M.mu+1)*sizeof(OLink));

           if(!(*T).rhead)

                     exit(0);

           (*T).chead=(OLink*)malloc((M.nu+1)*sizeof(OLink));

           if(!(*T).chead)

                     exit(0);

           for(i=1;i<=M.mu;i++)//初始化矩阵T的行头指针向量;各行链表为空链表

                     (*T).rhead[i]=NULL;

           for(i=1;i<=M.nu;i++)//初始化矩阵T的列头指针向量;各列链表为空链表

                     (*T).chead[i]=NULL;

           for(i=1;i<=M.mu;i++)//按行复制

           {

                     p=M.rhead[i];

                     while(p)//没到行尾

                     {

                                q=(OLNode*)malloc(sizeof(OLNode));//生成结点

                                if(!q)

                                          exit(0);

                                q->i=p->i;//给结点赋值

                                q->j=p->j;

                                q->e=p->e;

                                if(!(*T).rhead[i])//插在行表头

                                          (*T).rhead[i]=q1=q;

                                else//插在行表尾

                                          q1=q1->right=q;

                                if(!(*T).chead[q->j])//插在列表头

                                {

                                          (*T).chead[q->j]=q;

                                          q->down=NULL;

                                }

                                else//插在列表尾

                                {

                                          q2=(*T).chead[q->j];

                                         while(q2->down)

                                                     q2=q2->down;

                                          q2->down=q;

                                          q->down=NULL;

                                }

                                p=p->right;

                     }

                     q->right=NULL;

           }

           return1;

}

 

 

8.  矩阵加法

将矩阵M和N相加，得到矩阵Q。

如果行、列不相等则不能相加，直接退出。

按行的顺序相加。

如果对比两个列的大小，相等则进行相加，相加后要判断是否为0.

不为零则创建一个新的OLNode.

然后将这些节点插入到行链表，列链表中。

最后如果M或者N在行的数量上多，则都插入到矩阵Q中。

最后将指向列的最后的指针down设置为NULL。

 

int AddSMatrix(CrossListM,CrossListN,CrossList *Q)

{

           inti,k;

           OLinkp,pq,pm,pn;

           OLink*col;

 

           if(M.mu!=N.mu||M.nu!=N.nu)

           {

                     printf("两个矩阵不是同类型的,不能相加\n");

                     exit(0);

           }

           (*Q).mu=M.mu;//初始化Q矩阵

           (*Q).nu=M.nu;

           (*Q).tu=0;//元素个数的初值

           (*Q).rhead=(OLink*)malloc(((*Q).mu+1)*sizeof(OLink));

           if(!(*Q).rhead)

                     exit(0);

           (*Q).chead=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));

           if(!(*Q).chead)

                     exit(0);

           for(k=1;k<=(*Q).mu;k++)//初始化Q的行头指针向量;各行链表为空链表

                     (*Q).rhead[k]=NULL;

           for(k=1;k<=(*Q).nu;k++)//初始化Q的列头指针向量;各列链表为空链表

                     (*Q).chead[k]=NULL;

           //生成指向列的最后结点的数组

           col=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));

           if(!col)

                     exit(0);

           for(k=1;k<=(*Q).nu;k++)//赋初值

                     col[k]=NULL;

           for(i=1;i<=M.mu;i++)//按行的顺序相加

           {

                     pm=M.rhead[i];   // pm指向矩阵M的第i行的第1个结点

                     pn=N.rhead[i];   // pn指向矩阵N的第i行的第1个结点

                     while(pm&&pn)   // pm和pn均不空

                     {

                                if(pm->j<pn->j)//矩阵M当前结点的列小于矩阵N当前结点的列

                                {

                                          p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                         if(!p)

                                                     exit(0);

                                          (*Q).tu++;   // 非零元素数加1

                                          p->i=i;       // 给结点赋值

                                          p->j=pm->j;

                                          p->e=pm->e;

                                          p->right=NULL;

                                          pm=pm->right;//pm指针向右移

                                }

                                elseif(pm->j>pn->j)//矩阵M当前结点的列大于矩阵N当前结点的列

                                {

                                          p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                         if(!p)

                                                     exit(0);

                                          (*Q).tu++;   // 非零元素数加1

                                          p->i=i;       // 给结点赋值

                                          p->j=pn->j;

                                          p->e=pn->e;

                                          p->right=NULL;

                                          pn=pn->right;//pn指针向右移

                                }

                                //矩阵M、N当前结点的列相等且两元素之和不为0

                                elseif(pm->e+pn->e)

                                {

                                          p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                         if(!p)

                                                     exit(0);

                                          (*Q).tu++;//非零元素数加1

                                          p->i=i;//给结点赋值

                                          p->j=pn->j;

                                          p->e=pm->e+pn->e;

                                          p->right=NULL;

                                          pm=pm->right;//pm指针向右移

                                          pn=pn->right;//pn指针向右移

                                }

                                else//矩阵M、N当前结点的列相等且两元素之和为0

                                {

                                          pm=pm->right;//pm指针向右移

                                          pn=pn->right;//pn指针向右移

                                         continue;

                                }

                                if((*Q).rhead[i]==NULL)//p为该行的第1个结点

                                         //p插在该行的表头且pq指向p(该行的最后一个结点)

                                                     (*Q).rhead[i]=pq=p;

                                else//插在pq所指结点之后

                                {

                                          pq->right=p;//完成行插入

                                          pq=pq->right;//pq指向该行的最后一个结点

                                }

                                if((*Q).chead[p->j]==NULL)//p为该列的第1个结点

                                         //p插在该列的表头且col[p->j]指向p 

                                                     (*Q).chead[p->j]=col[p->j]=p;

                                else//插在col[p->]所指结点之后

                                {

                                          col[p->j]->down=p;//完成列插入

                                         //col[p->j]指向该列的最后一个结点

                                          col[p->j]=col[p->j]->down;

                                }

                     }

                     while(pm)//将矩阵M该行的剩余元素插入矩阵Q

                     {

                                p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                if(!p)

                                          exit(0);

                                (*Q).tu++;//非零元素数加1

                                p->i=i;//给结点赋值

                                p->j=pm->j;

                                p->e=pm->e;

                                p->right=NULL;

                                pm=pm->right;//pm指针向右移

                                if((*Q).rhead[i]==NULL)// p为该行的第1个结点

                                         //p插在该行的表头且pq指向p(该行的最后一个结点)

                                                     (*Q).rhead[i]= pq = p; 

                                else//插在pq所指结点之后

                                {

                                          pq->right=p;//完成行插入

                                          pq=pq->right;//pq指向该行的最后一个结点

                                }

                                if((*Q).chead[p->j]==NULL)// p为该列的第1个结点

                                         //p插在该列的表头且col[p->j]指向p

                                                     (*Q).chead[p->j]= col[p->j] = p;

                                else//插在col[p->j]所指结点之后

                                {

                                          col[p->j]->down=p;//完成列插入

                                         //col[p->j]指向该列的最后一个结点

                                          col[p->j]=col[p->j]->down; 

                                }

                     }

                     while(pn)//将矩阵N该行的剩余元素插入矩阵Q

                     {

                                p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                if(!p)

                                          exit(0);

                                (*Q).tu++;//非零元素数加1

                                p->i=i;//给结点赋值

                                p->j=pn->j;

                                p->e=pn->e;

                                p->right=NULL;

                                pn=pn->right;//pm指针向右移

                                if((*Q).rhead[i]==NULL)//p为该行的第1个结点

                                         //p插在该行的表头且pq指向p(该行的最后一个结点)

                                                     (*Q).rhead[i]=pq=p; 

                                else//插在pq所指结点之后

                                {

                                          pq->right=p;//完成行插入

                                          pq=pq->right;//pq指向该行的最后一个结点

                                }

                                if((*Q).chead[p->j]==NULL)//p为该列的第1个结点

                                         //p插在该列的表头且col[p->j]指向p 

                                                     (*Q).chead[p->j]=col[p->j]=p;

                                else//插在col[p->j]所指结点之后

                                {

                                          col[p->j]->down=p;//完成列插入

                                         //col[p->j]指向该列的最后一个结点

                                          col[p->j]=col[p->j]->down; 

                                }

                     }

           }

           for(k=1;k<=(*Q).nu;k++)

                     if(col[k])//k列有结点

                                col[k]->down=NULL;//  令该列最后一个结点的down指针为空

           free(col);

           return1;

}

 

9.  矩阵减法

基本同加法。

10.      矩阵乘法

只有当矩阵A的列数与矩阵B的行数相等时A×B才有意义。一个m×n的矩阵a(m,n)左乘一个n×p的矩阵b(n,p)，会得到一个m×p的矩阵c(m,p)。左乘：又称前乘，就是乘在左边(即乘号前)，比如说,A左乘E即AE。

先根据MXN，确定了Q的行列数量。

然后M的行与N的列，每项相乘后进行相加累计，如果不为零。则插入到Q矩阵中。

 

int MultSMatrix(CrossListM,CrossListN,CrossList *Q)

{

           inti,j,e;

           OLinkq,p0,q0,q1,q2;

 

           InitSMatrix(Q);

           (*Q).mu=M.mu;

           (*Q).nu=N.nu;

           (*Q).tu=0;

           (*Q).rhead=(OLink*)malloc(((*Q).mu+1)*sizeof(OLink));

           if(!(*Q).rhead)

                     exit(0);

           (*Q).chead=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));

           if(!(*Q).chead)

                     exit(0);

           for(i=1;i<=(*Q).mu;i++)//初始化矩阵Q的行头指针向量;各行链表为空链表

                     (*Q).rhead[i]=NULL;

           for(i=1;i<=(*Q).nu;i++)//初始化矩阵Q的列头指针向量;各列链表为空链表

                     (*Q).chead[i]=NULL;

           for(i=1;i<=(*Q).mu;i++)

                     for(j=1;j<=(*Q).nu;j++)

                     {

                                p0=M.rhead[i];

                                q0=N.chead[j];

                                e=0;

                                while(p0&&q0)

                                {

                                         if(q0->i<p0->j)

                                                     q0=q0->down;//列指针后移

                                         elseif(q0->i>p0->j)

                                                     p0=p0->right;//行指针后移

                                         else//q0->i==p0->j

                                          {

                                                     e+=p0->e*q0->e;//乘积累加

                                                     q0=q0->down;//行列指针均后移

                                                     p0=p0->right;

                                          }

                                }

                                if(e)//值不为0

                                {

                                          (*Q).tu++;//非零元素数加1

                                          q=(OLink)malloc(sizeof(OLNode));//生成结点

                                         if(!q)//生成结点失败

                                                     exit(0);

                                          q->i=i;//给结点赋值

                                          q->j=j;

                                          q->e=e;

                                          q->right=NULL;

                                          q->down=NULL;

                                         if(!(*Q).rhead[i])//行表空时插在行表头

                                                     (*Q).rhead[i]=q1=q;

                                         else//否则插在行表尾

                                                     q1=q1->right=q;

                                         if(!(*Q).chead[j])//列表空时插在列表头

                                                     (*Q).chead[j]=q;

                                         else//否则插在列表尾

                                          {

                                                     q2=(*Q).chead[j];//q2指向j行第1个结点

                                                    while(q2->down)

                                                               q2=q2->down;//q2指向j行最后1个结点

                                                     q2->down=q;

                                          }

                                }

                     }

                     return1;

}

11.      转置矩阵

矩阵转置是一个数学概念，于19世纪由英国数学家凯利首先提出。在数学上，矩阵指纵横排列的二维数据表格，来自于方程组的系数及常数所构成的方阵；矩阵概念在生产实践中也有许多应用，比如矩阵图法以及保护个人帐号的矩阵卡系统（由深圳网域提出）等。

定义A的转置为这样一个n×m阶矩阵B，满足B=a(j,i)，即 b (i,j)=a(j,i)（B的第i行第j列元素是A的第j行第i列元素），记A'=B。(有些书记为AT=B，这里T为A的上标）

 

int TransposeSMatrix(CrossListM,CrossList *T)

{

           intu,i;

           OLink*head,p,q,r;

           if((*T).rhead)

                     DestroySMatrix(T);

           CopySMatrix(M,T);//T=M

           u=(*T).mu;//交换(*T).mu和(*T).nu

           (*T).mu=(*T).nu;

           (*T).nu=u;

           head=(*T).rhead;//交换(*T).rhead和(*T).chead

           (*T).rhead=(*T).chead;

           (*T).chead=head;

           for(u=1;u<=(*T).mu;u++)//对T的每一行

           {

                     p=(*T).rhead[u];//p为行表头

                     while(p)//没到表尾,对T的每一结点

                     {

                                q=p->down;//q指向下一个结点

                                i=p->i;//交换.i和.j

                                p->i=p->j;

                                p->j=i;

                                r=p->down;//交换.down.和right

                                p->down=p->right;

                                p->right=r;

                                p=q;//p指向下一个结点

                     }

           }

           return1;

}

 

 

 

12.      Main函数

得到如下图4：

 

13.      源码

源码如下：

#include<stdio.h>

#include<malloc.h>

#include"stdlib.h"

typedefintElemType;//稀疏矩阵的十字链表存储表示

 

typedefstructOLNode

{

           inti,j;   // 该非零元的行和列下标

           ElemTypee;   // 非零元素值

           structOLNode*right,*down;// 该非零元所在行表和列表的后继链域

}OLNode, *OLink;

typedefstruct//行和列链表头指针向量基址,由CreatSMatrix_OL()分配

{

           OLink*rhead, *chead;

           intmu, nu, tu;       //稀疏矩阵的行数、列数和非零元个数

}CrossList;

// 初始化M(CrossList类型的变量必须初始化,否则创建、复制矩阵将出错)

int InitSMatrix(CrossList *M)

{

           (*M).rhead=(*M).chead=NULL;

           (*M).mu=(*M).nu=(*M).tu=0;

           return1;

}

// 销毁稀疏矩阵M

int DestroySMatrix(CrossList *M)

{

           inti;

           OLNode*p,*q;

 

           for(i=1;i<=(*M).mu;i++)//按行释放结点

           {

                     p=*((*M).rhead+i);

                     while(p)

                     {

                                q=p;

                                p=p->right;

                                free(q);

                     }

           }

           free((*M).rhead);

           free((*M).chead);

           (*M).rhead=(*M).chead=NULL;

           (*M).mu=(*M).nu=(*M).tu=0;

           return1;

}

// 创建稀疏矩阵M,采用十字链表存储表示。

int CreateSMatrix(CrossList *M)

{

           inti,j,k,m,n,t;

           ElemTypee;

           OLNode*p,*q;

           if((*M).rhead)

                     DestroySMatrix(M);

           printf("请输入稀疏矩阵的行数列数非零元个数:(space) ");

           scanf("%d%d%d",&m,&n,&t);

           (*M).mu=m;

           (*M).nu=n;

           (*M).tu=t;

           //初始化行链表头

           (*M).rhead=(OLink*)malloc((m+1)*sizeof(OLink));

           if(!(*M).rhead)

                     exit(0);

           //初始化列链表头

           (*M).chead=(OLink*)malloc((n+1)*sizeof(OLink));

           if(!(*M).chead)

                     exit(0);

           for(k=1;k<=m;k++)//初始化行头指针向量;各行链表为空链表

                     (*M).rhead[k]=NULL;

           for(k=1;k<=n;k++)//初始化列头指针向量;各列链表为空链表

                     (*M).chead[k]=NULL;

           printf("请按任意次序输入%d个非零元的行列元素值:（空格）\n",(*M).tu);

           for(k=0;k<t;k++)

           {

                     scanf("%d%d%d",&i,&j,&e);

                     p=(OLNode*)malloc(sizeof(OLNode));

                     if(!p)

                                exit(0);

                     p->i=i;//生成结点

                     p->j=j;

                     p->e=e;

                     if((*M).rhead[i]==NULL||(*M).rhead[i]->j>j)   

                     {

                                //p插在该行的第一个结点处

                                p->right=(*M).rhead[i];

                                (*M).rhead[i]=p;

                     }

                     else//寻查在行表中的插入位置

                     {

                                //从该行的行链表头开始，直到找到

                                for(q=(*M).rhead[i];q->right && q->right->j < j;q = q->right)

                                          ;

                                p->right=q->right;//完成行插入

                                q->right=p;

                     }

                     if((*M).chead[j]==NULL || (*M).chead[j]->i> i)

                     {

                                //p插在该列的第一个结点处

                                p->down= (*M).chead[j];

                                (*M).chead[j]= p;

                     }

                     else//寻查在列表中的插入位置

                     {

                                for(q= (*M).chead[j];q->down &&q->down->i < i;q = q->down)

                                           ;

                                p->down=q->down;//完成列插入

                                q->down=p;

                     }

           }

           return1;

}

// 按行或按列输出稀疏矩阵M

int PrintSMatrix(CrossListM)

{

           inti,j;

           OLinkp;

           printf("%d行%d列%d个非零元素\n",M.mu,M.nu,M.tu);

           printf("请输入选择(1.按行输出2.按列输出):");

           scanf("%d",&i);

           switch(i)

           {

           case1:

                     for(j=1;j<=M.mu;j++)

                     {

                                p=M.rhead[j];

                                while(p)

                                {

                                          printf("%d行%d列值为%d\n",p->i,p->j,p->e);

                                          p=p->right;

                                }

                     }

                     break;

           case2:

                     for(j=1;j<=M.nu;j++)

                     {

                                p=M.chead[j];

                                while(p)

                                {

                                          printf("%d行%d列值为%d\n",p->i,p->j,p->e);

                                          p=p->down;

                                }

                     }

           }

           return1;

}

// 由稀疏矩阵M复制得到T

int CopySMatrix(CrossListM,CrossList *T)

{

           inti;

           OLinkp,q,q1,q2;

 

           if((*T).rhead)

                     DestroySMatrix(T);

           (*T).mu=M.mu;

           (*T).nu=M.nu;

           (*T).tu=M.tu;

           (*T).rhead=(OLink*)malloc((M.mu+1)*sizeof(OLink));

           if(!(*T).rhead)

                     exit(0);

           (*T).chead=(OLink*)malloc((M.nu+1)*sizeof(OLink));

           if(!(*T).chead)

                     exit(0);

           for(i=1;i<=M.mu;i++)//初始化矩阵T的行头指针向量;各行链表为空链表

                     (*T).rhead[i]=NULL;

           for(i=1;i<=M.nu;i++)//初始化矩阵T的列头指针向量;各列链表为空链表

                     (*T).chead[i]=NULL;

           for(i=1;i<=M.mu;i++)//按行复制

           {

                     p=M.rhead[i];

                     while(p)//没到行尾

                     {

                                q=(OLNode*)malloc(sizeof(OLNode));//生成结点

                                if(!q)

                                          exit(0);

                                q->i=p->i;//给结点赋值

                                q->j=p->j;

                                q->e=p->e;

                                if(!(*T).rhead[i])//插在行表头

                                          (*T).rhead[i]=q1=q;

                                else//插在行表尾

                                          q1=q1->right=q;

                                if(!(*T).chead[q->j])//插在列表头

                                {

                                          (*T).chead[q->j]=q;

                                          q->down=NULL;

                                }

                                else//插在列表尾

                                {

                                          q2=(*T).chead[q->j];

                                         while(q2->down)

                                                     q2=q2->down;

                                          q2->down=q;

                                          q->down=NULL;

                                }

                                p=p->right;

                     }

                     q->right=NULL;

           }

           return1;

}

// 求稀疏矩阵的和Q=M+N

int AddSMatrix(CrossListM,CrossListN,CrossList *Q)

{

           inti,k;

           OLinkp,pq,pm,pn;

           OLink*col;

 

           if(M.mu!=N.mu||M.nu!=N.nu)

           {

                     printf("两个矩阵不是同类型的,不能相加\n");

                     exit(0);

           }

           (*Q).mu=M.mu;//初始化Q矩阵

           (*Q).nu=M.nu;

           (*Q).tu=0;//元素个数的初值

           (*Q).rhead=(OLink*)malloc(((*Q).mu+1)*sizeof(OLink));

           if(!(*Q).rhead)

                     exit(0);

           (*Q).chead=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));

           if(!(*Q).chead)

                     exit(0);

           for(k=1;k<=(*Q).mu;k++)//初始化Q的行头指针向量;各行链表为空链表

                     (*Q).rhead[k]=NULL;

           for(k=1;k<=(*Q).nu;k++)//初始化Q的列头指针向量;各列链表为空链表

                     (*Q).chead[k]=NULL;

           //生成指向列的最后结点的数组

           col=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));

           if(!col)

                     exit(0);

           for(k=1;k<=(*Q).nu;k++)//赋初值

                     col[k]=NULL;

           for(i=1;i<=M.mu;i++)//按行的顺序相加

           {

                     pm=M.rhead[i];   // pm指向矩阵M的第i行的第1个结点

                     pn=N.rhead[i];   // pn指向矩阵N的第i行的第1个结点

                     while(pm&&pn)   // pm和pn均不空

                     {

                                if(pm->j<pn->j)//矩阵M当前结点的列小于矩阵N当前结点的列

                                {

                                          p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                         if(!p)

                                                     exit(0);

                                          (*Q).tu++;   // 非零元素数加1

                                          p->i=i;       // 给结点赋值

                                          p->j=pm->j;

                                          p->e=pm->e;

                                          p->right=NULL;

                                          pm=pm->right;//pm指针向右移

                                }

                                elseif(pm->j>pn->j)//矩阵M当前结点的列大于矩阵N当前结点的列

                                {

                                          p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                         if(!p)

                                                     exit(0);

                                          (*Q).tu++;   // 非零元素数加1

                                          p->i=i;       // 给结点赋值

                                          p->j=pn->j;

                                          p->e=pn->e;

                                          p->right=NULL;

                                          pn=pn->right;//pn指针向右移

                                }

                                //矩阵M、N当前结点的列相等且两元素之和不为0

                                elseif(pm->e+pn->e)

                                {

                                          p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                         if(!p)

                                                     exit(0);

                                          (*Q).tu++;//非零元素数加1

                                          p->i=i;//给结点赋值

                                          p->j=pn->j;

                                          p->e=pm->e+pn->e;

                                          p->right=NULL;

                                          pm=pm->right;//pm指针向右移

                                          pn=pn->right;//pn指针向右移

                                }

                                else//矩阵M、N当前结点的列相等且两元素之和为0

                                {

                                          pm=pm->right;//pm指针向右移

                                          pn=pn->right;//pn指针向右移

                                         continue;

                                }

                                if((*Q).rhead[i]==NULL)//p为该行的第1个结点

                                         //p插在该行的表头且pq指向p(该行的最后一个结点)

                                                     (*Q).rhead[i]=pq=p;

                                else//插在pq所指结点之后

                                {

                                          pq->right=p;//完成行插入

                                          pq=pq->right;//pq指向该行的最后一个结点

                                }

                                if((*Q).chead[p->j]==NULL)//p为该列的第1个结点

                                         //p插在该列的表头且col[p->j]指向p 

                                                     (*Q).chead[p->j]=col[p->j]=p;

                                else//插在col[p->]所指结点之后

                                {

                                          col[p->j]->down=p;//完成列插入

                                         //col[p->j]指向该列的最后一个结点

                                          col[p->j]=col[p->j]->down;

                                }

                     }

                     while(pm)//将矩阵M该行的剩余元素插入矩阵Q

                     {

                                p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                if(!p)

                                          exit(0);

                                (*Q).tu++;//非零元素数加1

                                p->i=i;//给结点赋值

                                p->j=pm->j;

                                p->e=pm->e;

                                p->right=NULL;

                                pm=pm->right;//pm指针向右移

                                if((*Q).rhead[i]==NULL)// p为该行的第1个结点

                                         //p插在该行的表头且pq指向p(该行的最后一个结点)

                                                     (*Q).rhead[i]= pq = p; 

                                else//插在pq所指结点之后

                                {

                                          pq->right=p;//完成行插入

                                          pq=pq->right;//pq指向该行的最后一个结点

                                }

                                if((*Q).chead[p->j]==NULL)// p为该列的第1个结点

                                         //p插在该列的表头且col[p->j]指向p

                                                     (*Q).chead[p->j]= col[p->j] = p;

                                else//插在col[p->j]所指结点之后

                                {

                                          col[p->j]->down=p;//完成列插入

                                         //col[p->j]指向该列的最后一个结点

                                          col[p->j]=col[p->j]->down; 

                                }

                     }

                     while(pn)//将矩阵N该行的剩余元素插入矩阵Q

                     {

                                p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                if(!p)

                                          exit(0);

                                (*Q).tu++;//非零元素数加1

                                p->i=i;//给结点赋值

                                p->j=pn->j;

                                p->e=pn->e;

                                p->right=NULL;

                                pn=pn->right;//pm指针向右移

                                if((*Q).rhead[i]==NULL)//p为该行的第1个结点

                                         //p插在该行的表头且pq指向p(该行的最后一个结点)

                                                     (*Q).rhead[i]=pq=p; 

                                else//插在pq所指结点之后

                                {

                                          pq->right=p;//完成行插入

                                          pq=pq->right;//pq指向该行的最后一个结点

                                }

                                if((*Q).chead[p->j]==NULL)//p为该列的第1个结点

                                         //p插在该列的表头且col[p->j]指向p 

                                                     (*Q).chead[p->j]=col[p->j]=p;

                                else//插在col[p->j]所指结点之后

                                {

                                          col[p->j]->down=p;//完成列插入

                                         //col[p->j]指向该列的最后一个结点

                                          col[p->j]=col[p->j]->down; 

                                }

                     }

           }

           for(k=1;k<=(*Q).nu;k++)

                     if(col[k])//k列有结点

                                col[k]->down=NULL;//  令该列最后一个结点的down指针为空

           free(col);

           return1;

}

 

//  求稀疏矩阵的差Q=M-N

int SubtSMatrix(CrossListM,CrossListN,CrossList *Q)

{

           inti,k;

           OLinkp,pq,pm,pn;

           OLink*col;

 

           if(M.mu!=N.mu||M.nu!=N.nu)

           {

                     printf("两个矩阵不是同类型的,不能相加\n");

                     exit(0);

           }

           (*Q).mu=M.mu;//初始化Q矩阵

           (*Q).nu=M.nu;

           (*Q).tu=0;//元素个数的初值

           (*Q).rhead=(OLink*)malloc(((*Q).mu+1)*sizeof(OLink));

           if(!(*Q).rhead)

                     exit(0);

           (*Q).chead=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));

           if(!(*Q).chead)

                     exit(0);

           for(k=1;k<=(*Q).mu;k++)//初始化Q的行头指针向量;各行链表为空链表

                     (*Q).rhead[k]=NULL;

           for(k=1;k<=(*Q).nu;k++)//初始化Q的列头指针向量;各列链表为空链表

                     (*Q).chead[k]=NULL;

           //生成指向列的最后结点的数组

           col=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));

           if(!col)

                     exit(0);

           for(k=1;k<=(*Q).nu;k++)//赋初值

                     col[k]=NULL;

           for(i=1;i<=M.mu;i++)//按行的顺序相加

           {

                     pm=M.rhead[i];//pm指向矩阵M的第i行的第1个结点

                     pn=N.rhead[i];//pn指向矩阵N的第i行的第1个结点

                     while(pm&&pn)//pm和pn均不空

                     {

                                if(pm->j<pn->j)//矩阵M当前结点的列小于矩阵N当前结点的列

                                {

                                          p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                         if(!p)

                                                     exit(0);

                                          (*Q).tu++;//非零元素数加1

                                          p->i=i;//给结点赋值

                                          p->j=pm->j;

                                          p->e=pm->e;

                                          p->right=NULL;

                                          pm=pm->right;//pm指针向右移

                                }

                                //矩阵M当前结点的列大于矩阵N当前结点的列

                                elseif(pm->j>pn->j)

                                {

                                          p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                         if(!p)

                                                     exit(0);

                                          (*Q).tu++;//非零元素数加1

                                          p->i=i;//给结点赋值

                                           p->j=pn->j;

                                          p->e=-pn->e;

                                          p->right=NULL;

                                          pn=pn->right;//pn指针向右移

                                }

                                elseif(pm->e-pn->e)

                                {

                                         //矩阵M、N当前结点的列相等且两元素之差不为0

                                          p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                         if(!p)

                                                     exit(0);

                                          (*Q).tu++;//非零元素数加1

                                          p->i=i;//给结点赋值

                                          p->j=pn->j;

                                          p->e=pm->e-pn->e;

                                          p->right=NULL;

                                          pm=pm->right;//pm指针向右移

                                          pn=pn->right;//pn指针向右移

                                }

                                else//矩阵M、N当前结点的列相等且两元素之差为0

                                {

                                          pm=pm->right;//pm指针向右移

                                          pn=pn->right;//pn指针向右移

                                         continue;

                                }

                                if((*Q).rhead[i]==NULL)//p为该行的第1个结点

                                         //p插在该行的表头且pq指向p(该行的最后一个结点)

                                                     (*Q).rhead[i]=pq=p; 

                                else//插在pq所指结点之后

                                {

                                          pq->right=p;//完成行插入

                                          pq=pq->right;//pq指向该行的最后一个结点

                                }

                                if((*Q).chead[p->j]==NULL)//p为该列的第1个结点

                                         //p插在该列的表头且col[p->j]指向p

                                                     (*Q).chead[p->j]=col[p->j]=p; 

                                else//插在col[p->]所指结点之后

                                {

                                          col[p->j]->down=p;//完成列插入

                                         //col[p->j]指向该列的最后一个结点

                                          col[p->j]=col[p->j]->down; 

                                }

                     }

                     while(pm)//将矩阵M该行的剩余元素插入矩阵Q

                     {

                                p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                if(!p)

                                          exit(0);

                                (*Q).tu++;//非零元素数加1

                                p->i=i;//给结点赋值

                                p->j=pm->j;

                                p->e=pm->e;

                                p->right=NULL;

                                pm=pm->right;//pm指针向右移

                                if((*Q).rhead[i]==NULL)//p为该行的第1个结点

                                         //p插在该行的表头且pq指向p(该行的最后一个结点)

                                                     (*Q).rhead[i]=pq=p; 

                                else//插在pq所指结点之后

                                {

                                          pq->right=p;//完成行插入

                                          pq=pq->right;//pq指向该行的最后一个结点

                                }

                                if((*Q).chead[p->j]==NULL)//p为该列的第1个结点

                                         //p插在该列的表头且col[p->j]指向p 

                                                     (*Q).chead[p->j]=col[p->j]=p;

                                else//插在col[p->j]所指结点之后

                                {

                                          col[p->j]->down=p;//完成列插入

                                         //col[p->j]指向该列的最后一个结点

                                          col[p->j]=col[p->j]->down; 

                                }

                     }

                     while(pn)//将矩阵N该行的剩余元素插入矩阵Q

                     {

                                p=(OLink)malloc(sizeof(OLNode));//生成矩阵Q的结点

                                if(!p)

                                          exit(0);

                                (*Q).tu++;//非零元素数加1

                                p->i=i;//给结点赋值

                                p->j=pn->j;

                                p->e=-pn->e;

                                p->right=NULL;

                                pn=pn->right;//pm指针向右移

                                if((*Q).rhead[i]==NULL)//p为该行的第1个结点

                                         //p插在该行的表头且pq指向p(该行的最后一个结点)

                                                     (*Q).rhead[i]=pq=p; 

                                else//插在pq所指结点之后

                                {

                                          pq->right=p;//完成行插入

                                          pq=pq->right;//pq指向该行的最后一个结点

                                }

                                if((*Q).chead[p->j]==NULL)//p为该列的第1个结点

                                         //p插在该列的表头且col[p->j]指向p

                                                     (*Q).chead[p->j]=col[p->j]=p; 

                                else//插在col[p->j]所指结点之后

                                {

                                          col[p->j]->down=p;//完成列插入

                                         //col[p->j]指向该列的最后一个结点 

                                          col[p->j]=col[p->j]->down;

                                }

                     }

           }

           for(k=1;k<=(*Q).nu;k++)

                     if(col[k])//k列有结点

                                col[k]->down=NULL;//令该列最后一个结点的down指针为空

           free(col);

           return1;

}

// 求稀疏矩阵乘积Q=M*N

int MultSMatrix(CrossListM,CrossListN,CrossList *Q)

{

           inti,j,e;

           OLinkq,p0,q0,q1,q2;

 

           InitSMatrix(Q);

           (*Q).mu=M.mu;

           (*Q).nu=N.nu;

           (*Q).tu=0;

           (*Q).rhead=(OLink*)malloc(((*Q).mu+1)*sizeof(OLink));

           if(!(*Q).rhead)

                     exit(0);

           (*Q).chead=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));

           if(!(*Q).chead)

                     exit(0);

           for(i=1;i<=(*Q).mu;i++)//初始化矩阵Q的行头指针向量;各行链表为空链表

                     (*Q).rhead[i]=NULL;

           for(i=1;i<=(*Q).nu;i++)//初始化矩阵Q的列头指针向量;各列链表为空链表

                     (*Q).chead[i]=NULL;

           for(i=1;i<=(*Q).mu;i++)

                     for(j=1;j<=(*Q).nu;j++)

                     {

                                p0=M.rhead[i];

                                q0=N.chead[j];

                                e=0;

                                while(p0&&q0)

                                {

                                         if(q0->i<p0->j)

                                                     q0=q0->down;//列指针后移

                                         elseif(q0->i>p0->j)

                                                     p0=p0->right;//行指针后移

                                         else//q0->i==p0->j

                                          {

                                                     e+=p0->e*q0->e;//乘积累加

                                                     q0=q0->down;//行列指针均后移

                                                     p0=p0->right;

                                          }

                                }

                                if(e)//值不为0

                                {

                                          (*Q).tu++;//非零元素数加1

                                           q=(OLink)malloc(sizeof(OLNode));//生成结点

                                         if(!q)//生成结点失败

                                                     exit(0);

                                          q->i=i;//给结点赋值

                                          q->j=j;

                                          q->e=e;

                                          q->right=NULL;

                                          q->down=NULL;

                                         if(!(*Q).rhead[i])//行表空时插在行表头

                                                     (*Q).rhead[i]=q1=q;

                                         else//否则插在行表尾

                                                     q1=q1->right=q;

                                         if(!(*Q).chead[j])//列表空时插在列表头

                                                     (*Q).chead[j]=q;

                                         else//否则插在列表尾

                                          {

                                                     q2=(*Q).chead[j];//q2指向j行第1个结点

                                                    while(q2->down)

                                                               q2=q2->down;//q2指向j行最后1个结点

                                                     q2->down=q;

                                          }

                                }

                     }

                     return1;

}

//  求稀疏矩阵M的转置矩阵T

int TransposeSMatrix(CrossListM,CrossList *T)

{

           intu,i;

           OLink*head,p,q,r;

 

           if((*T).rhead)

                     DestroySMatrix(T);

           CopySMatrix(M,T);//T=M

           u=(*T).mu;//交换(*T).mu和(*T).nu

           (*T).mu=(*T).nu;

           (*T).nu=u;

           head=(*T).rhead;//交换(*T).rhead和(*T).chead

           (*T).rhead=(*T).chead;

           (*T).chead=head;

           for(u=1;u<=(*T).mu;u++)//对T的每一行

           {

                     p=(*T).rhead[u];//p为行表头

                     while(p)//没到表尾,对T的每一结点

                     {

                                q=p->down;//q指向下一个结点

                                i=p->i;//交换.i和.j

                                p->i=p->j;

                                p->j=i;

                                r=p->down;//交换.down.和right

                                p->down=p->right;

                                p->right=r;

                                p=q;//p指向下一个结点

                     }

           }

           return1;

}

int main()

{

           CrossListA,B,C;

           InitSMatrix(&A);//CrossList类型的变量在初次使用之前必须初始化

           InitSMatrix(&B);

           printf("创建矩阵A: ");

           CreateSMatrix(&A);

           PrintSMatrix(A);

           printf("由矩阵A复制矩阵B:");

           CopySMatrix(A,&B);

           PrintSMatrix(B);

           DestroySMatrix(&B);//CrossList类型的变量在再次使用之前必须先销毁

           printf("销毁矩阵B后:\n");

           PrintSMatrix(B);

           printf("创建矩阵B2:(与矩阵A的行、列数相同，行、列分别为%d,%d)\n",

                     A.mu,A.nu);

           CreateSMatrix(&B);

           PrintSMatrix(B);

           printf("矩阵C1(A+B): ");

           AddSMatrix(A,B,&C);

           PrintSMatrix(C);

           DestroySMatrix(&C);

           printf("矩阵C2(A-B): ");

           SubtSMatrix(A,B,&C);

           PrintSMatrix(C);

           DestroySMatrix(&C);

           printf("矩阵C3(A的转置): ");

           TransposeSMatrix(A,&C);

           PrintSMatrix(C);

           DestroySMatrix(&A);

           DestroySMatrix(&B);

           DestroySMatrix(&C);

           printf("创建矩阵A2: ");

           CreateSMatrix(&A);

           PrintSMatrix(A);

           printf("创建矩阵B3:(行数应与矩阵A2的列数相同=%d)\n",A.nu);

           CreateSMatrix(&B);

           PrintSMatrix(B);

           printf("矩阵C5(A*B): ");

           MultSMatrix(A,B,&C);

           PrintSMatrix(C);

           DestroySMatrix(&A);

           DestroySMatrix(&B);

           DestroySMatrix(&C);

           system("pause");

           return0;

}