稀疏矩阵相乘

//存储结构
//在十字链表中，稀疏矩阵的每一行用一个带表头结点的循环链表表示
//每一列也用一个带表头的循环链表表示，在这个结构中，除了表头结点外，每个节点都代表矩阵中的非零元素
//它由5个域组成：行，列，数据，向下指针，向右指针

//结点结构和存储表示如下图：



fig1. 交叉矩阵结构
//行域 列域 值域
//向下指针 向右指针

//为了使所有结点的存储结构一致，规定表头结点的结构与非零元素结点完全一致，只是将其行域和列域置为零
//由于每一行链表的表头与每一列链表的表头的行域和列域值均为零，故这两组表头结点可以公用
//即同行号、同列号的行头和列头共存储在一个结点之中，只是将其逻辑分开，起到共享资源的效果
//由此，得到稀疏矩阵的十字链表表示的结点总数等于非零元素个数+行头、列头+总表头

//由于十字链表表示的稀疏矩阵中，元素在稀疏矩阵中的具体位置不像二组数组矩阵那样，可以由矩阵元素的下标来对应相乘
//在稀疏矩阵的存储中，是通过行、列的链式交叉存储来实现的，零元素在矩阵中没有存储
//所以矩阵A的行和矩阵B的列在相乘的时候，要求寻找对应元素才能相乘，在元素相乘并移动指针的过程中
//当矩阵A的某行和矩阵B的某列相乘时，A矩阵X行中元素的列号col和B矩阵Y列中元素的行号row相同时才能相乘

//程序代码如下：

#include<stdio.h>
#include<iostream.h>
#include"head.h"

matrixType *crosslink()
{
int m,n,t,s,i,r,c,v;
matrixType *h[MAXSIZE],*p,*q;
cout<<"行数m，列数n，非零元素个数t："<<endl;

cin>>m>>n>>t;
p=new matrixType;
p->row=m;
p->col=n;
h[0]=p;
s=m>n?m:n;
for(i=1;i<=s;i++)
{
p=new matrixType;
p->row=p->col=0;
p->right=p->down=p;
h[i]=p;
h[i-1]->tag.next=p;
}
h[s]->tag.next=h[0];

for(i=1;i<=t;i++)
{
cout<<"第"<<i<<"个元素（行号r，列号c，值v）："<<endl;
cin>>r>>c>>v;
p=new matrixType;
p->row=r;
p->col=c;
p->tag.val=v;
q=h[r];
while(q->right!=h[r]&&q->right->col<c)
q=q->right;
p->right=q->right;
q->right=p;
q=h[c];
while(q->down!=h[c]&&q->down->row<r)
q=q->down;
p->down=q->down;
q->down=p;
}

return (h[0]);

}

void dispcrosslink(matrixType *hm)
{
matrixType *p,*q;
cout<<"按行表输出矩阵元素："<<endl;
cout<<"row="<<hm->row;
cout<<"\tcol="<<hm->col<<endl;
p=hm->tag.next;
while(p!=hm)
{
q=p->right;
while(q!=p)
{
cout<<" "<<q->row<<" "<<q->col<<" "<<q->tag.val<<endl;
q=q->right;
}
p=p->tag.next;
}
}

matrixType *multiply(matrixType *hm1,matrixType *hm2)
{
int sum,i,j,s,k;
matrixType *p1,*p2,*p,*q1,*q2,*q,*h[MAXSIZE];
s=hm1->row>hm2->col?hm1->row:hm2->col;
p=new matrixType;
p->row=hm1->row;
p->col=hm2->col;
h[0]=p;
for(i=1;i<=s;i++)
{
p=new matrixType;
p->row=p->col=0;
p->right=p->down=p;
h[i]=p;
h[i-1]->tag.next=p;
}
h[s]->tag.next=h[0];

p1=hm1->tag.next;
for(i=1;i<=hm1->row;i++)
{
p2=hm2->tag.next;
for(j=1;j<=hm2->col;j++)
{
sum=0;
q1=p1->right;
q2=p2->down;

for(k=1;k<=hm2->row;k++)
{
if(q1==p1||q2==p2) break;

if(q1->col==q2->row)
{
sum+=q1->tag.val*q2->tag.val;
q1=q1->right;
q2=q2->down;
}
else if(q1->col>q2->row)
{
q2=q2->down;
}
else
{
q1=q1->right;
}
}

if(sum!=0)
{
p=new matrixType;
p->row=i;
p->col=j;
p->tag.val=sum;
q=h[i];
while(q->right!=h[i])
q=q->right;
p->right=h[i];
q->right=p;
q=h[j];
while(q->down!=h[j])
q=q->down;
p->down=h[j];
q->down=p;
}

p2=p2->tag.next;
}
p1=p1->tag.next;
}

return (h[0]);
}

int main()
{
matrixType *hm1,*hm2,*hm3;
hm1=crosslink();
dispcrosslink(hm1);
hm2=crosslink();
dispcrosslink(hm2);
if(hm1->col!=hm2->row)
cout<<"若A矩阵的列不等于B矩阵的行，则两矩阵不能相乘！"<<endl;
else
{
hm3=multiply(hm1,hm2);
cout<<"相乘后的矩阵为："<<endl;
dispcrosslink(hm3);
}

system("PAUSE");
return 0;
}

//head.h
#define MAXSIZE 10

typedef struct linknode
{
int row,col;
struct linknode *right,*down;
union
{
int val;
struct linknode *next;
}tag;
}matrixType;

此算法主体思想来源于网上，但原程序不能运算，稍加更改，并做了一些优化，主要还是阐述两稀疏矩阵相乘，定义数据结构以及在A矩阵的列号等于B矩阵的行号时相乘。