稀疏矩阵的加减乘求逆运算Word文档格式.docx
《稀疏矩阵的加减乘求逆运算Word文档格式.docx》由会员分享，可在线阅读，更多相关《稀疏矩阵的加减乘求逆运算Word文档格式.docx（27页珍藏版）》请在冰点文库上搜索。
intrpos[MAXROW+1];
//各行第一个非零元素的位置表
}RLSMatrix;
//输入三元组矩阵
template<
classT>
boolInputTSMatrix（T&
M,inty）
cout<
<
"
输入矩阵的行数、列数和非零元素个数:
;
cin>
>
M.rows>
M.cols>
M.nzeroNums;
请输入非零元素对应的行号、列号和相应的元素值:
<
endl;
for（inti=1;
i<
=M.nzeroNums;
i++）
{
M.data[i].r>
M.data[i].c>
M.data[i].v;
}
returntrue;
}
//输出矩阵，按标准格式输出
boolOutputSMatrix（TM）
inti,j,k=1;
for（i=0;
M.rows;
for（j=0;
j<
M.cols;
j++）
if（（M.data[k].r-1）==i&
&
（M.data[k].c-1）==j）
setw（4）<
M.data[k].v;
k++;
else
0"
}//end_j
}//end_i
//求稀疏矩阵的转置
intTranSMatrix（）
TSMatrixM,T;
InputTSMatrix（M,0）;
intcol,p,q=1;
T.rows=M.cols;
T.cols=M.rows;
T.nzeroNums=M.nzeroNums;
if（T.nzeroNums）
for（col=1;
col<
=M.cols;
col++）
for（p=1;
p<
p++）
if（M.data[p].c==col）
T.data[q].r=M.data[p].c;
T.data[q].c=M.data[p].r;
T.data[q].v=M.data[p].v;
++q;
}//end_p
}//end_col
}//end_if
运用普通转置算法,输入矩阵的转置矩阵为:
OutputSMatrix（T）;
return1;
//稀疏矩阵的快速转置
intFastTranMat（）
intnum[MAXROW+1];
//表示矩阵M中第col列非零元素的个数
intcpot[MAXROW+1];
//表示矩阵M中第col列第一个非0元素在b.data中的位置
intp,q,col,t;
//输入稀疏矩阵
col++）//M中各列元素初始化
num[col]=0;
for（t=1;
t<
t++）
++num[M.data[t].c];
//求M中每一列非零元个数
//求第col列第一个非零元在b.data中的序号
cpot[1]=1;
for（col=2;
cpot[col]=cpot[col-1]+num[col-1];
col=M.data[p].c;
//稀疏矩阵M中每个元素对应的列号
q=cpot[col];
//稀疏矩阵M中第一个非零元素位置
++cpot[col];
}//end_for
运用快速算法，输入矩阵的转置为:
//求取稀疏矩阵每一行非零元个数
boolCount（RLSMatrix&
M）
introw,p;
for（row=1;
row<
=M.rows;
row++）
num[row]=0;
//清零
++num[M.data[p].r];
//统计M每一行非零元个数
M.rpos[1]=1;
//M中每一行非零元的起始位置
for（row=2;
M.rpos[row]=M.rpos[row-1]+num[row-1];
//两个稀疏矩阵的乘法
boolMultSMatrix（）
RLSMatrixM,N,Q;
//构建三个带链接信息的三元组表示的数组
InputTSMatrix（M,1）;
//用普通三元组形式输入数组
InputTSMatrix（N,1）;
Count（M）;
Count（N）;
if（M.cols!
=N.rows）
Error!
"
returnfalse;
//Q的初始化
Q.rows=M.rows;
Q.cols=N.cols;
Q.nzeroNums=0;
intmrow,nrow,p,q,t,tp,qcol;
intctemp[MAXROW+1];
//辅助数组
//如果Q是非零矩阵
if（M.nzeroNums*N.nzeroNums）
for（mrow=1;
mrow<
mrow++）
//当前行各元素累加器清零
for（intx=1;
x<
=N.cols;
x++）
ctemp[x]=0;
}//end_x
//当前行的首个非零元素在三元组中的位置为此行前所有非0元素加1
Q.rpos[mrow]=Q.nzeroNums+1;
if（mrow<
M.rows）
tp=M.rpos[mrow+1];
tp=M.nzeroNums+1;
for（p=M.rpos[mrow];
tp;
p++）
//对当前行的每个非零元素操作
nrow=M.data[p].c;
//在N中找到与M操作元素的c值相等的行值r
if（nrow<
N.rows）
t=N.rpos[nrow+1];
t=N.nzeroNums+1;
//对找出的行的每个非零元素进行操作
for（q=N.rpos[nrow];
q<
t;
q++）
qcol=N.data[q].c;
//将乘得到的对应值放在相应元素的累加器里面
ctemp[qcol]+=M.data[p].v*N.data[q].v;
}//p_end_for
//对已经求出的累加器中的值压缩到Q中
for（qcol=1;
qcol<
=Q.cols;
qcol++）
if（ctemp[qcol]）
if（++Q.nzeroNums>
MAXSIZE）
return0;
Q.data[Q.nzeroNums].r=mrow;
Q.data[Q.nzeroNums].c=qcol;
Q.data[Q.nzeroNums].v=ctemp[qcol];
}//qcol_end_for
}//arow_end_for
两个稀疏矩阵相乘的结果为:
\n"
OutputSMatrix（Q）;
//两个稀疏矩阵的加法
intAddMatrix（）
TSMatrixA,B,C;
inti=1,j=1,k=1;
//i,j,k分别用以保存A、B、C非零元素个数
intvalue=0;
InputTSMatrix（A,0）;
InputTSMatrix（B,0）;
if（A.rows!
=B.rows||A.cols!
=B.cols）
两个稀疏矩阵的大小不等,不能相加!
if（A.rows==B.rows&
A.cols==B.cols）
while（i<
=A.nzeroNums&
=B.nzeroNums）
if（A.data[i].r==B.data[j].r）
if（A.data[i].c<
B.data[j].c）
C.data[k].r=A.data[i].r;
C.data[k].c=A.data[i].c;
C.data[k].v=A.data[i].v;
i++;
elseif（A.data[i].c>
C.data[k].r=B.data[j].r;
C.data[k].c=B.data[j].c;
C.data[k].v=B.data[j].v;
j++;
value=A.data[i].v+B.data[j].v;
if（value!
=0）
C.data[k].v=value;
elseif（A.data[i].r<
B.data[j].r）
//把剩余部分元素存入C中
if（i>
A.nzeroNums&
for（;
=B.nzeroNums;
if（i<
j>
B.nzeroNums）
=A.nzeroNums;
}//end_while
C.rows=A.rows;
C.cols=A.cols;
C.nzeroNums=k-1;
输出两个稀疏矩阵的和:
OutputSMatrix（C）;
//两个稀疏矩阵的减法
intSubMatrix（）
intm=1,n=1,k=1,temp;
C.nzeroNums=0;
while（m<
n<
if（A.data[m].r==B.data[n].r）
if（A.data[m].c==B.data[n].c）
temp=A.data[m].v-B.data[n].v;
if（temp!
C.data[k].r=A.data[m].r;
C.data[k].c=A.data[m].c;
C.data[k].v=temp;
m++;
n++;
elseif（A.data[m].c<
B.data[n].c）
升级会员 