数据结构 课程设计Word文档格式.docx
《数据结构 课程设计Word文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构 课程设计Word文档格式.docx（17页珍藏版）》请在冰点文库上搜索。
=
*
二．设计思路
A.行逻辑链接的顺序表为了便于随机存取任意一行的非零元，则需知道每一行的第一个非零元在三元组表中的位置。
为此，可将指示“行”信息的辅助数组cpot固定在稀疏矩阵的存储结构中
B.数据结构的选用为了实现稀疏矩阵的各种运算，采用三元组的方式储存矩阵
C.矩阵的各种运算为了求2和矩阵的各类运算，只需要在相乘2个矩阵中相对应的各个元素的j值和i值相运算即可
三．解决问题
【主程序模块】：
voidmain（）
{
初始化;
do{
接受命令;
处理命令;
}while（命令!
=“退出”）；
}
【功能模块调用关系图】
主程序模块
创建稀疏矩阵模块
运算稀疏矩阵模块
打印稀疏矩阵模块
【详细设计】
稀疏矩阵运算器
矩阵相乘
矩阵相加
矩阵相减
退出本系统
输入矩阵1
输入矩阵2
计算结果
typedefstruct{
introw;
//行数
intcol;
//列数
intv;
//非零元素值
}triplenode;
triplenodedata[maxsize+1];
//非零元三元组
introwtab[maxrow+1];
//各行第一个非零元的位置表
intmu,nu,tu;
//矩阵的行数、列数和非零元个数
}rtripletable;
voidcreat（rtripletable&
A）//创建稀疏矩阵
voidprint（rtripletableA）//输出稀疏矩阵
intaddsmatrix（rtripletableM,rtripletableN）//矩阵相加
intsubsmatrix（rtripletableM,rtripletableN）//稀疏矩阵相减
voidmultsmatrix（rtripletableM,rtripletableN,rtripletable&
Q）//稀疏矩阵相乘
四．实现
1．功能函数设计
ADTArray{
数据对象:
D={aij|0≤i≤b1-1,0≤j≤b2-1}
数据关系:
R={ROW,COL}
ROW={<
ai,j,ai+1,j>
|0≤i≤b1-2,0≤j≤b2-1}
COL={<
ai,j,ai,j+1>
|0≤i≤b1-1,0≤j≤b2-2}
基本操作：
CreateSMatrix（&
M）;
//操作结果:
创建稀疏矩阵M.
PrintSMatrix（M）;
//初始化条件:
稀疏矩阵M存在.
//操作结果:
输出稀疏矩阵M.
AddSMatrix（M,N,&
Q）;
稀疏矩阵M与N的行数和列数对应相等.
求稀疏矩阵的和Q=M+N.
SubSMatrix（M,N,&
求稀疏矩阵的差Q=M-N.
MultSMatrix（M,N,&
稀疏矩阵M的列数等于N的行数.
求稀疏矩阵的乘积Q=M*N.
}ADTArray
【源程序】
#include<
stdio.h>
stdlib.h>
iostream.h>
#definemaxsize100
#definemaxrow100
#defineOK1
#defineERROR-1
typedefstruct
introw;
intcol;
intv;
triplenodedata[maxsize+1];
introwtab[maxrow+1];
intmu,nu,tu;
intk=1,sum=1,loop,p,t;
intnum[maxrow+1];
cout<
<
"
请输入矩阵的行数和列数:
endl;
行数:
;
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;
intresult[maxrow+1][maxrow+1];
intloop1,loop2;
for（loop1=1;
loop1<
loop1++）
for（loop2=1;
loop2<
=A.nu;
loop2++）
result[loop1][loop2]=0;
//初始化为0
for（loop1=1;
result[A.data[loop1].row][A.data[loop1].col]=A.data[loop1].v;
{
cout<
|"
for（loop2=1;
cout<
result[loop1][loop2]<
//输出所做运算的结果
}
{
if（M.mu!
=N.mu）//行数相等才能相加
cout<
出错"
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;
=N.mu）//行数相等才能相减
Q.mu=M.mu;
Q.nu=N.nu;
if（M.data[p].v-N.data[q].v!
=0）//两个稀疏矩阵相减的结果不为0
Q.data[k].v=M.data[p].v-N.data[q].v;
++k;
if（M.data[p].col<
N.data[q].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;
减法结果为:
intarow,brow;
intp,q,tp,t;
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（p=1;
=Q.nu;
p++）//处理M的每一列
ctemp[p]=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.nu）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（）
charchoice;
rtripletableA,B,Q;
--------------------------------------------------\n"
|*****欢迎使用稀疏矩阵运算器******|\n"
|=============================|\n"
\n|A、输入矩阵1|\n"
\n|B、输入矩阵2|\n"
\n|C、矩阵相加|\n"
\n|D、矩阵相减|\n"
\n|E、矩阵相乘|\n"
\n|F、退出本系统|\n"
\n|-----------------------------------------------|\n"
请选择所需要的操作功能（A，B，C，D，E，F）:
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'
exit（0）;
}cout<
}while
（1）;
运行与测试
实验总结：
调试程序时，应注意矩阵的调用。
比如，开始时没有注意将程序调用！
尽管实现了矩阵的转置和相加，但没有符合题意。
在调试时，才意识到是以前经常发的一个错误，就是在最后加了一个return0，这是错误的！
在编写程序时体会到了团队合作的精神，这是将来走进社会不可缺少的！
实验成绩
学号
姓名
课题小组自评分数
最后得分
093821029
093821033
093821034
093821036
升级会员 