稀疏矩阵完整版Word文档格式.docx
《稀疏矩阵完整版Word文档格式.docx》由会员分享，可在线阅读，更多相关《稀疏矩阵完整版Word文档格式.docx（19页珍藏版）》请在冰点文库上搜索。
行数:
;
cin>
>
A.mu;
列数:
A.nu;
非零元素个数:
A.tu;
请按行列值的形式输入该矩阵的非零元"
for（loop=1;
loop<
=A.tu;
loop++）
{
cin>
A.data[loop].row>
A.data[loop].col>
A.data[loop].v;
//输入三元组的行数，列数和非零元素值
}
for（p=1;
p<
=A.mu;
p++）num[p]=0;
//A三元组每一列的非零元素个数
for（t=1;
t<
t++）++num[A.data[t].row];
//求A中每一列含非零元个数
A.rowtab[1]=1;
//求第p列中第一个非零元在A.data中的序号
for（t=2;
t++）A.rowtab[t]=A.rowtab[t-1]+num[t-1];
return;
}
voidprint（rtripletableA）//输出稀疏矩阵
intresult[maxrow+1][maxrow+1];
//定义一个二维数组
intloop1,loop2;
for（loop1=1;
loop1<
loop1++）
for（loop2=1;
loop2<
=A.nu;
loop2++）
result[loop1][loop2]=0;
//初始化为0
result[A.data[loop1].row][A.data[loop1].col]=A.data[loop1].v;
cout<
|"
cout<
result[loop1][loop2]<
//输出所做运算的结果
intaddsmatrix（rtripletableM,rtripletableN）
//矩阵相加
{
if（M.mu!
=N.mu）//行数相等才能相加
出错"
rtripletableQ;
Q.mu=M.mu;
Q.nu=N.nu;
intp,q,k;
p=1;
q=1;
k=1;
while（p<
=M.tu&
&
q<
=N.tu）//两个稀疏矩阵存在
if（M.data[p].row==N.data[q].row）
//两个稀疏矩阵的行数相等
{
if（M.data[p].col==N.data[q].col）
//两个稀疏矩阵的列数相等
{
if（M.data[p].v+N.data[q].v!
=0）
//两个稀疏矩阵相加的结果不为0
{
Q.data[k].row=M.data[p].row;
Q.data[k].col=M.data[p].col;
Q.data[k].v=M.data[p].v+N.data[q].v;
++k;
}
++q;
++p;
}
elseif（M.data[p].col<
N.data[q].col）
//第一个稀疏矩阵列数小于第二个稀疏矩阵列数
Q.data[k]=M.data[p];
//把M中的所有信息都赋给Q
++p;
else
//第一个稀疏矩阵列数大于第二个稀疏矩阵的列数
Q.data[k]=N.data[q];
++q;
}
elseif（M.data[p].row<
N.data[q].row）
//第一个稀疏矩阵行列数小于第二个稀疏矩阵行数
Q.data[k]=M.data[p];
else
Q.data[k]=N.data[q];
=M.tu）//只有M并且符合条件
Q.data[k]=M.data[p];
while（q<
=N.tu）//只有N并且符合条件
Q.data[k]=N.data[q];
++q;
Q.tu=k-1;
加法结果为:
print（Q）;
//调用print（）
returnOK;
intsubsmatrix（rtripletableM,rtripletableN）
//稀疏矩阵相减
Q.mu=M.mu;
Q.nu=N.nu;
if（M.data[p].v-N.data[q].v!
//两个稀疏矩阵相减的结果不为0
{Q.data[k].row=M.data[p].row;
Q.data[k].col=M.data[p].col;
Q.data[k].v=M.data[p].v-N.data[q].v;
++k;
if（M.data[p].col<
//第一个稀疏矩阵列数小于第二个稀疏矩阵的列数
if（M.data[p].col>
//第一个稀疏矩阵列数大于第二个稀疏矩阵的列
Q.data[k].row=N.data[q].row;
Q.data[k].col=N.data[q].col;
Q.data[k].v=-N.data[q].v;
if（M.data[p].row<
++p;
if（M.data[p].row>
//第一个稀疏矩阵行列数大于第二个稀疏矩阵行数
Q.data[k].row=N.data[q].row;
Q.data[k].col=N.data[q].col;
Q.data[k].v=-N.data[q].v;
Q.data[k].row=N.data[q].row;
Q.data[k].col=N.data[q].col;
Q.data[k].v=-N.data[q].v;
减法结果为:
print（Q）;
voidmultsmatrix（rtripletableM,rtripletableN,rtripletable&
Q）//稀疏矩阵相乘
intarow,brow;
intp,q,tp,t,x;
intccol;
intctemp[maxrow+1];
//定义累加器
if（M.nu!
=N.mu）return;
Q.tu=0;
//Q初始化
if（M.tu*N.tu!
=0）{//Q是非零矩阵
for（arow=1;
arow<
=M.mu;
arow++）
//处理M的每一行
for（x=1;
x<
=Q.nu;
x++）//处理M的每一列
ctemp[x]=0;
//当前行各元素累加器清零
Q.rowtab[arow]=Q.tu+1;
if（arow<
M.mu）tp=M.rowtab[arow+1];
elsetp=M.tu+1;
for（p=M.rowtab[arow];
tp;
++p）
//对当前行中每一个非零元
brow=M.data[p].col;
//找到对应元N中的行号
if（brow<
N.mu）t=N.rowtab[brow+1];
elset=N.tu+1;
for（q=N.rowtab[brow];
t;
++q）
ccol=N.data[q].col;
//乘积元素在Q中列数
ctemp[ccol]+=M.data[p].v*N.data[q].v;
}//求得Q中第crow（=arow）行的非零元
for（ccol=1;
ccol<
ccol++）
//压缩存储该行非零元
if（ctemp[ccol]）
if（++Q.tu>
maxsize）return;
Q.data[Q.tu].row=arow;
//行数
Q.data[Q.tu].col=ccol;
Q.data[Q.tu].v=ctemp[ccol];
//累加非零元素值
乘法结果为:
//调用print（）
intFastTranMat（rtripletableM,rtripletable&
Q）
intnum[maxrow+1];
//表示矩阵M中第col列非零元素的个数
intcpot[maxrow+1];
//表示矩阵M中第col列第一个非0元素在b.data中的位置
intp,q,col,t;
Q.mu=M.mu;
Q.nu=M.nu;
Q.tu=M.tu;
if（Q.tu）
for（col=1;
col<
=M.nu;
col++）//M中各列元素初始化
num[col]=0;
for（t=1;
t<
=M.tu;
t++）
++num[M.data[t].col];
//求M中每一列非零元个数
//求第col列第一个非零元在b.data中的序号
cpot[1]=1;
for（col=2;
col++）
cpot[col]=cpot[col-1]+num[col-1];
for（p=1;
p<
p++）
col=M.data[p].col;
//稀疏矩阵M中每个元素对应的列号
q=cpot[col];
//稀疏矩阵M中第一个非零元素位置
Q.data[q].row=M.data[p].col;
Q.data[q].col=M.data[p].row;
Q.data[q].v=M.data[p].v;
++cpot[col];
}//end_for
}//end_if
cout<
"
运用快速算法，输入矩阵的转置为:
<
endl;
print（Q）;
returnOK;
intJsMatrix（ints[][maxrow],intn）
inti,j,k,r,total=0;
intb[sizenum][sizenum];
//b[N][N]用于存放在矩阵s[N][N]中元素s[0]的余之式
if（n==1）
total=s[0][0];
elseif（n==2）
total=s[0][0]*s[1][1]-s[0][1]*s[1][0];
}
else
for（i=0;
i<
n;
i++）
for（j=0;
j<
n-1;
j++）
for（k=0;
k<
k++）
if（k>
=i）
b[j][k]=s[j+1][k+1];
b[j][k]=s[j+1][k];
}//end_for_k
}//end_for_j
if（i%2==0）
r=s[0][i]*JsMatrix（b,n-1）;
//递归调用
r=（-1）*s[0][i]*JsMatrix（b,n-1）;
total+=r;
}//end_for_i
}//end_else
returntotal;
//求原矩阵个元素对应的余之式,存放在b[n][n]中,定义为float型
voidN1Matrix（ints[][sizenum],floatb[][sizenum],intn）
inti,j,k,l,m,g,a[sizenum][sizenum];
m=i;
g=j;
for（l=0;
l<
l++）
=m&
l>
=g）
a[k][l]=s[k+1][l+1];
elseif（k<
m&
a[k][l]=s[k][l+1];
elseif（k>
g）
a[k][l]=s[k+1][l];
a[k][l]=s[k][l];
}//end_for_l
b[i][j]=JsMatrix（a,n-1）;
//稀疏矩阵求逆
voidInverseMat（rtripletableM,rtripletable&
inti,j,k,n=M.mu;
floattemp;
inta[sizenum][sizenum];
floatb[sizenum][sizenum],c[sizenum][sizenum];
i++）//初始化矩阵a
a[i][j]=0;
for（i=1;
i++）//给矩阵a赋值
a[M.data[i].row-1][M.data[i].col-1]=M.data[i].v;
稀疏矩阵对应的普通矩阵为:
\n"
print（M）;
k=JsMatrix（a,n）;
矩阵的行列式值:
|A|="
if（k==0）
行列式的值为0,原矩阵无逆矩阵!
N1Matrix（a,b,n）;
//调用函数，得到原矩阵各元素对应的余之式存放在数组b[n][n]中
//求代数余之式
普通矩阵各元素对应的代数余之式矩阵为:
i++）
if（（i+j）%2!
=0&
b[i][j]!
=0）
b[i][j]=-b[i][j];
{printf（"
）;
%f"
//对b[N][N]转置，此时b[n][n]存放的为原矩阵的伴随矩阵
for（j=i+1;
temp=b[i][j];
b[i][j]=b[j][i];
b[j][i]=temp;
伴随矩阵A*:
i++）//打印伴随矩阵A*
printf（"
}printf（"
i++）//求逆矩阵，此时c[n][n]中存放的是原矩阵的逆矩阵
c[i][j]=b[i][j]/k;
逆矩阵（A*）/|A|:
i++）//打印逆矩阵
setw（6）<
c[i][j]<
setw（6）;
voidmain（）
{charchoice;
rtripletableA,B,Q;
|*****欢迎使用稀疏矩阵运算器******|\n"
\nA、输入矩阵1\n"
\nB、输入矩阵2\n"
\nC、矩阵相加\n"
\nD、矩阵相减\n"
\nE、矩阵相乘\n"
\nF、矩阵转置\n"
\nG、矩阵求逆\n"
\nH、退出本系统\n"
请选择所需要的操作功能（A，B，C，D，E，F，G，H）:
do{
choice;
switch（choice）{
case'
A'
:
creat（A）;
break;
B'
creat（B）;
C'
addsmatrix（A,B）;
D'
subsmatrix（A,B）;
E'
multsmatrix（A,B,Q）;
F'
FastTranMat（A,Q）;
G'
InverseMat（rtripletableM,rtripletable&
Q）;
}cout<
}while
（1）;
}}
升级会员 