课程设计稀疏矩阵应用Word文档下载推荐.docx
《课程设计稀疏矩阵应用Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《课程设计稀疏矩阵应用Word文档下载推荐.docx（24页珍藏版）》请在冰豆网上搜索。
目前已经可以用于人脸识别、子空间方法预处理技术稀疏近似逆按模最小特征值修正矩阵广义极小残余方法等方面。
1.3任务与分析
（1）给出算法并编程实现；
（2）任给实例并演示求解结果；
（3）给出时间复杂度分析；
（4）结合所完成题目，分析总结各算法所使用的算法设计技术，以及相应技术的基本思想。
2程序的主要功能
2.1三元组的转置
将一个按三元组存储的稀疏矩阵进行转置。
2.2三元组的加法
将两个按三元组存储的稀疏矩阵进行相加并得出结果。
2.3三元组的减法
将两个按三元组存储的稀疏矩阵进行相减并得出结果。
2.4三元组的乘法
将两个按三元组存储的稀疏矩阵进行相乘并得出结果。
2.5十字链表的转置
将一个按十字链表存储的稀疏矩阵进行转置。
2.6十字链表的加法
将两个按十字链表存储的稀疏矩阵进行相加并得出结果。
2.7十字链表的减法
2.8十字链表的乘法
3程序运行平台
VC++6.0。
编译，链接，执行。
4总体设计
图4.1系统总体框架图
5程序类的说明
∙OLNode结构声明
typedefstructOLNode
{
inti,j;
inte;
structOLNode*right,*down;
}OLNode,*OLink;
∙Crosslist结构的声明
typedefstruct
intmu,nu,tu;
OLink*rhead,*chead;
}CrossList;
∙Triple结构的声明
typedefstruct
}Triple;
∙TSMatrix结构的声明
Tripledata[maxsize];
intrpos[maxsize+1];
intnu,mu,tu;
}TSMatrix;
6模块分析
6.1三元组的转置
将一个按三元组存储的稀疏矩阵进行转置（非快速转置）。
voidTransposeSMatrix（TSMatrixM,TSMatrix&
T）//三元组的转置
T.nu=M.mu;
T.mu=M.nu;
T.tu=M.tu;
intq=1;
for（intcol=1;
col<
=M.nu;
col++）
for（intp=1;
p<
=M.tu;
p++）
if（M.data[p].j==col）
{
T.data[q].i=M.data[p].j;
T.data[q].j=M.data[p].i;
T.data[q].e=M.data[p].e;
q++;
}
}
intCompare（inta1,intb1,inta2,intb2）
if（a1>
a2）return1;
elseif（a1<
a2）
return-1;
elseif（b1>
b2）
return1;
if（b1<
else
return0;
6.2三元组减法
用户再输入一个稀疏矩阵，系统将两个矩阵进行加运算并得出结果。
voidAddTMatix（TSMatrixM,TSMatrixT,TSMatrix&
S）//三元组相加
S.mu=M.mu>
T.mu?
M.mu:
T.mu;
S.nu=M.nu>
T.nu?
M.nu:
T.nu;
S.tu=0;
intce;
intmcount=1,tcount=1;
while（mcount<
=M.tu&
&
tcount<
=T.tu）
{
switch（Compare（M.data[mcount].i,M.data[mcount].j,T.data[tcount].i,T.data[tcount].j））
{
case-1:
S.data[q].e=M.data[mcount].e;
S.data[q].i=M.data[mcount].i;
S.data[q].j=M.data[mcount].j;
mcount++;
break;
case1:
S.data[q].e=T.data[tcount].e;
S.data[q].i=T.data[tcount].i;
S.data[q].j=T.data[tcount].j;
tcount++;
case0:
ce=M.data[mcount].e+T.data[tcount].e;
if（ce）
{
S.data[q].e=ce;
S.data[q].i=M.data[mcount].i;
S.data[q].j=M.data[mcount].j;
q++;
mcount++;
tcount++;
}
else
}
}
=M.tu）
S.data[q].e=M.data[mcount].e;
S.data[q].i=M.data[mcount].i;
S.data[q].j=M.data[mcount].j;
q++;
mcount++;
while（tcount<
S.data[q].e=T.data[tcount].e;
S.data[q].i=T.data[tcount].i;
S.data[q].j=T.data[tcount].j;
tcount++;
S.tu=q-1;
}…
6.3三元组的减法
用户再输入一个稀疏矩阵，系统将两个矩阵进行加运、减算并得出结果。
voidjianTMatix（TSMatrixM,TSMatrixT,TSMatrix&
S）//三元组相减
S.data[q].e=-T.data[tcount].e;
ce=M.data[mcount].e-T.data[tcount].e;
S.data[q].e=-T.data[tcount].e;
6.4三元组的乘法
用户再输入一个稀疏矩阵，系统将其进行乘法运算并得出结果。
intMultSMatrix（TSMatrixM,TSMatrixN,TSMatrix&
Q）//三元组相乘
intarow,brow,ccol,i,t,ctemp[100],p,q,tp;
if（M.nu!
=N.mu）
Q.mu=M.mu;
Q.nu=N.nu;
Q.tu=0;
if（M.tu*N.tu!
=0）
for（arow=1;
arow<
=M.mu;
++arow）
for（i=0;
i<
=N.nu;
++i）
ctemp[i]=0;
Q.rpos[arow]=Q.tu+1;
if（arow<
M.mu）
tp=M.rpos[arow+1];
else
tp=M.tu+1;
for（p=M.rpos[arow];
tp;
++p）
brow=M.data[p].j;
if（brow<
N.mu）
t=N.rpos[brow+1];
else
t=N.tu+1;
for（q=N.rpos[brow];
q<
t++q）
ccol=N.data[q].j;
ctemp[ccol]+=M.data[p].e*N.data[q].e;
for（ccol=1;
ccol<
=Q.nu;
++ccol）
if（ctemp[ccol]）
if（++（Q.tu）>
maxsize）
return1;
Q.data[Q.tu].i=arow,Q.data[Q.tu].j=ccol,Q.data[Q.tu].e=ctemp[ccol];
}
}
return1;
6.5十字链表的转置
voidTurnSMatrix_OL（CrossList&
M）//十字链表转置
intcol,row;
OLinkp,q;
for（col=1;
q=p=M.rhead[col];
while（q）
row=p->
i;
p->
i=p->
j;
j=row;
q=p->
right;
right=p->
down;
down=q;
6.6十字链表的加法
intSMatrix_ADD（CrossList*A,CrossList*B）//十字链表相加
OLNode*pa,*pb,*pre,*p,*cp[100];
inti,j,t;
t=A->
tu+B->
tu;
for（j=1;
j<
=A->
nu;
j++）
cp[j]=A->
chead[j];
for（i=1;
mu;
i++）
pa=A->
rhead[i];
pb=B->
pre=NULL;
while（pb）
if（pa==NULL||pa->
j>
pb->
j）
p=（OLink）malloc（sizeof（OLNode））;
if（!
pre）
A->
rhead[i]=p;
pre->
right=p;
p->
right=pa;
pre=p;
i=i;
j=pb->
e=pb->
e;
A->
chead[p->
j]）
j]=cp[p->
j]=p;
p->
down=NULL;
cp[p->
j]->
down=p;
pb=pb->
elseif（pa->
pre=pa;
pa=pa->
e+pb->
e）
t--;
pa->
e+=pb->
else
{
t=t-2;
rhead[i]=pa->
right=pa->
p=pa;
if（A->
j]==p）
j]=p->
down=p->
free（p）;
A->
mu=A->
mu>
B->
mu?
mu:
nu=A->
nu>
nu?
nu:
6.7十字链表的减法
intSMatrix_jian（CrossList*A,CrossList*B）//十字链表相减
e=-pb->
e-pb->
e-=pb->
6.8十字链表的乘法
intMultSMatrix_OL（CrossListM,CrossListN,CrossList&
Q）//十字链表相乘
inti,j,e;
OLinkp0,q0,p,pl,pla;
if（M.nu!
=N.mu）//检查稀疏矩阵M的列数和N的行数是否对应相等
printf（"
稀疏矩阵A的列数和B的行数不相等，不能相乘。
\n"
）;
Q.nu=N.nu;
Q.tu=0;
if（!
（Q.rhead=（OLink*）malloc（（Q.mu+1）*sizeof（OLink））））
exit（-2）;
（Q.chead=（OLink*）malloc（（Q.nu+1）*sizeof（OLink））））
=Q.mu;
Q.rhead[i]=NULL;
i++）
Q.chead[i]=NULL;
i++）//相乘
for（j=1;
p0=M.rhead[i];
q0=N.chead[j];
e=0;
while（p0&
q0）//M第i行和N第j列有元素
if（p0->
j>
q0->
i）
q0=q0->
//M的列大于N的行，则N的列指针后移
elseif（p0->
j<
p0=p0->
//M的列小于N的行，则M的行指针右移
else//M的行等于N的列
e+=p0->
e*q0->
//乘积累加
down,p0=p0->
//移动指针
if（e）//乘积不为0
（p=（OLink）malloc（sizeof（OLNode））））
exit（-2）;
Q.tu++;
//非零元素增加
j=j;
e=e;
right=NULL;
//赋值，指针后移，将p插入十字链表行插入
if（Q.rhead[i]==NULL）//若p为该行的第1个结点
Q.rhead[i]=p=p;
//p插在该行的表头且pl指向p（该行的最后一个结点）
pl->
right=p,pl=p;
//插在pl所指结点之后，pl右移列插入
if（Q.chead[j]==NULL）//若p为该列的第一个结点
Q.chead[j]=p;
//该列的表头指向p
//插在列表尾
pla=Q.chead[j];
//pla指向j行的第1个结点
while（pla->
down）
pla=pla->
//pla指向j行最后一个结点
pla->
down=p;
return1;
7系统测试
首先进入VC++6.0，打开“稀疏矩阵应用.cpp”，编译后执行文件，按系统提示操作。
7.1三元组的转置
三元组的转置，实现。
7.2三元组的加法
三元组的加法，实现。
7.3三元组的减法
三元组的减法，实现。
7.4三元组的乘法
三元组的乘法，实现
升级会员 