(五)1.1_稀疏矩阵乘法的快速运算
一.问题描述
有矩阵M和N,都是用三元组压缩存储,设计高效率算法求矩阵M*N得到的矩阵Q(也用三元组压缩存储).
二.思路分析
假设矩阵M*N=Q 如下
那么得到的矩阵Q有三行三列,第一行中的元素有这样的关系
所以我们可以这样,在遍历到M11时,由于N11,N12,N13是在顺序表中连续排列的,所以我们可以创建一个3个累加器(int QElem[4]={0}),
遍历到M11时,先算Q11,Q12,Q13的第一项,累加到累加器中即
QElem[1]+=M11*N11,
QElem[2]+=M11*N12,
QElem[3]+=M11*N13,
然后遍历到M12时计算第二项,累加到累加器中即
QElem[1]+=M12*N21,
QElem[2]+=M12*N22,
QElem[3]+=M12*N23,
接着遍历到M13时计算第三项,累加到累加器中即
QElem[1]+=M13*N31,
QElem[2]+=M13*N32,
QElem[3]+=M13*N33,
这样Q中第一行的元素就计算出来了,我们把累加器里的值存到Q矩阵的顺序表中就ok了
接着重复上述步骤,遍历M矩阵的第2行元素,第三行也是同理
这样每行M中的元素只需遍历一次,就能计算出M乘以N得到得矩阵Q了,效率比普通算法更高
三.代码实现
这里来看一下代码的具体实现,注意这个算法需要一个附加信息,也就是矩阵每行第一个非零元素在顺序表中的位置序号,这个信息是为了能够准确遍历矩阵中的某行所有元素
#include"stdio.h"
#include"stdlib.h"
#define MAXSIZE 2000
//线性表0单元不用是为了便于理解程序
//元素类型
typedef int SqPosType;
typedef struct
{
int i; //行
int j; //列
SqPosType e; //元素
}Triple; //三元组
typedef struct
{
int mu,nu,tu; //矩阵的行数,列数,非零元素的数量
int SqPos[10]; //每行非零元素在顺序表(data)中的位置,SqPos[0]未用
Triple data[MAXSIZE+1]; //非零单元三元组表,data[0]未用
}RLSMatrix;
RLSMatrix M=
{
3,3,7,{0,1,3,5},
{
{0,0,0},
{1,1,1},
{1,3,3},
{2,2,2},
{2,3,4},
{3,1,3},
{3,2,4},
{3,3,3},
}
};
RLSMatrix N=
{
3,3,7,{0,1,3,6},
{
{0,0,0},
{1,1,3},
{1,2,2},
{2,1,2},
{2,2,3},
{2,3,2},
{3,2,2},
{3,3,3},
}
};
//矩阵相乘算法
void MultSmatrix(RLSMatrix M,RLSMatrix N,RLSMatrix &Q)
{
Q.mu=M.mu; //相乘得到的矩阵的行数等于矩阵M的行数
Q.nu=N.nu; //相乘得到的矩阵的列数等于矩阵N的列数
Q.tu=0; //相乘得到的矩阵的元素数量暂时未知,暂定为0
int M_row,N_row; //矩阵M,N的元素的行位置(在矩阵中)
//遍历存储M矩阵的所有行
for(M_row=1;M_row<=M.mu;M_row++)
{
int QElem[Q.nu+2]={0}; //一行中每列的元素的累加器
Q.SqPos[M_row]=Q.tu+1; //相乘得到的矩阵每行非零元素在顺序表中的位置
int SqPos2_M; //遍历到M矩阵的元素的下一行非零元素在顺序表中的位置
//为了找出相同行的元素在顺序表中的位置范围
if(M_row<M.mu)
SqPos2_M=M.SqPos[M_row+1]; //当前行的下一行非零元素在顺序表中的位置
else
SqPos2_M=M.tu+1; //当前行的下一行非零元素在顺序表中的位置,因为M_row+1超界了,所以用尾元素位置加一
int SqPos_M; //矩阵N中被遍历到的元素在顺序表中的位置
//遍历M矩阵中一行中的所有元素
for(SqPos_M=M.SqPos[M_row];SqPos_M<SqPos2_M;SqPos_M++)
{
N_row=M.data[SqPos_M].j; //通过M中元素的列位置,找到N中对应元素的行位置,M中a元素要乘以N中元素b;a b的关系是a在M中的列位置是b在N中的行位置
int SqPos2_N; //遍历到N矩阵的元素的下一行非零元素在顺序表中的位置
//为了找出相同行的元素在顺序表中的位置范围,其实作用为了遍历一行中的所有非零元素
if(N_row<N.mu)
SqPos2_N=N.SqPos[N_row+1]; //当前行的下一行非零元素在顺序表中的位置
else
SqPos2_N=N.tu+1; //当前行的下一行非零元素在顺序表中的位置,因为N_row+1超界了,所以用尾元素位置加一
int SqPos_N; //矩阵N中被遍历到的元素在顺序表中的位置
//遍历N矩阵中一行中的所有元素
for(SqPos_N=N.SqPos[N_row];SqPos_N<SqPos2_N;SqPos_N++)
{
int col=N.data[SqPos_N].j; //Q矩阵元素的列位置等于N矩阵的元素的列位置
QElem[col]+=M.data[SqPos_M].e*N.data[SqPos_N].e; //用累加器累加各一行中各列的元素的结果
}
}//for SqPos_M
//M中的一行元素已经和N中所有列的元素计算完了,现在遍历累加器中的元素,将计算得到的Q中一行的元素存入顺序表
for(int col=1;col<=Q.nu;col++)
{
if(QElem[col]!=0) //非零元素
{
++(Q.tu); //非零元素数量加一
Q.data[Q.tu]={M_row,col,QElem[col]}; //非零元素存入Q矩阵的顺序表
}
}//for col
}//for M_row
}
//显示三元组
void Print(RLSMatrix M)
{
int m=M.mu; //矩阵行数
int n=M.nu; //矩阵列数
int t=M.tu; //矩阵非零元素个数
printf("\n\n i j e\n\n");
for(int i=1;i<=t;i++)
{
printf("%4d%4d%4d\n",M.data[i].i,M.data[i].j,M.data[i].e); //显示三元组的三个元素
}
}
int main()
{
RLSMatrix Q; //初始化相乘后的矩阵Q
MultSmatrix(M,N,Q); //把矩阵M和矩阵N相乘得到矩阵赋值给矩阵Q
printf("\n矩阵M:\n");
Print(M);
printf("\n矩阵N:\n");
Print(N);
printf("\n矩阵Q=M*N:\n");
Print(Q); //显示Q矩阵的三元组
return 0;
}
操作结果:
四.算法概述
1.可以看到这里定义的存储矩阵三元组的结构体,还要存储矩阵每行第一个非零元素在顺序表中的位置序号,这是为了能够准确的遍历到矩阵某一行的所有元素
注意:我们为了更好的理解这个算法,所以很多数组零单元都是不使用的
2.算法中有3个层次的循环,第1层循环是依次遍历矩阵M的行,第2层循环是遍历M矩阵某行中的所有元素,第3层循环是遍历N矩阵中某行的所有元素,并分别与第2层循环遍历的M中的某个元素相乘然后结果分别加到Q的累加器中.
3.第2层循环有两个同层次的循环,
先进行遍历M某行所有元素的循环,通过累加器.计算出Q中某行所有元素的值.
然后我们再通过一个循环把累加器里的值存储到Q矩阵的顺序表