数据结构稀疏矩阵运算器课程设计报告书Word下载.docx
《数据结构稀疏矩阵运算器课程设计报告书Word下载.docx》由会员分享，可在线阅读，更多相关《数据结构稀疏矩阵运算器课程设计报告书Word下载.docx（23页珍藏版）》请在冰点文库上搜索。
4.3算法三：
矩阵乘法21
第五章程序调试23
第六章心得体会25
参考文献26
第一章需求分析
1．稀疏矩阵是指那些多数元素为零的矩阵。
利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。
实现一个能进行稀疏矩阵基本运算的运算器。
2．以“带行逻辑信息”的三元组顺序表表示稀疏矩阵，实现矩阵转置，求逆，实现两个矩阵相加、相减和相乘的运算。
稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则以通常的阵列形式列出。
3．演示程序以用户和计算机的对话方式执行，数组的建立方式为边输入边建立。
4．由题目要求可知：
首先应输入矩阵的行数和列数，并判别给出的两个矩阵的行、列数对于所要求作的运算是否相匹配。
5．程序可以对三元组的输入顺序不加以限制；
根据对矩阵的行列，三元组作直接插入排序，从而进行运算时,不会产生错误。
6．在用三元组表示稀疏矩阵时，相加、乘积和相减所得结果矩阵应该另生成；
矩阵求逆时，为了算法方便，使用二维数组存放。
7．程序在VC6.0环境下设计。
程序执行的命令为：
1.稀疏矩阵转置;
2.稀疏矩阵加法;
;
3.稀疏矩阵乘法;
4.退出
的工作。
第二章概要设计
1．抽象数据类型稀疏矩阵的定义如下：
ADTSparseMatrix{
数据对象：
D={aij|i=1,2,…,m;
j=1,2,…,n;
aij∈ElemSet,m和n分别为矩阵的行数和列数}
数据关系：
R={Row,Col}
Row={﹤ai,j,ai,j+1﹥|1≤i≤m,1≤j≤n-1}
Col={﹤ai,j,ai+1,j﹥|1≤i≤m-1,1≤j≤n}
基本操作：
create（TSMatrix&
TM）
操作结果：
创建稀疏矩阵矩阵TM
LocateELem（TSMatrixM,inti,intj,inte）
初始条件：
稀疏矩阵M存在
操作结果：
稀疏矩阵中是否存在非零元素A[i][j]，若存在返回e
disp（TSMatrixTM）
稀疏矩阵TM存在
通常形式输出稀疏矩阵
InsertSortMatrix（TSMatrix&
初始条件：
根据对矩阵的行列，三元组TM作直接插入排序
TransposeSMatrix（TSMatrixM,TSMatrix&
T）
稀疏矩阵M和T存在
求稀疏矩阵M转置的稀疏矩阵T
AddTSM（TSMatrixA,TSMatrixB,TSMatrix&
C）
稀疏矩阵A，B和C存在
稀疏矩阵的加法运算:
C=A+B
SubTSM（TSMatrixA,TSMatrixB,TSMatrix&
稀疏矩阵的减法运算:
C=A-B
MultSMatrix（TSMatrixA,TSMatrixB,TSMatrix&
稀疏矩阵的乘法运算:
C=A×
B
NiMatrix（TSMatrix&
稀疏矩阵求逆
}ADTSparseMatrix;
2.主程序：
voidmain（）
{初始化；
do{
接受命令；
选择处理命令；
}while（命令！
=“退出”）
}
3.本程序有四个模块，调用关系如下：
主程序模块
图2.1
4本程序的流程图
开始
图2.2
第3章设计步骤
3.1函数说明
稀疏矩阵的三元组顺序表存储表示：
typedefstruct//定义三元组的元素
{
inti,j;
intv;
}Triple;
classtripletable
{//设计类来描述稀疏矩阵及其操作
public:
aaa*pdata;
tripledata[maxsize];
intrpos[maxsize];
tripletable（）;
~tripletable（）;
voidconvert（）;
voidadd（）;
voidmulti（）;
private:
intm;
intn;
intt;
inta;
};
主要函数：
~tripletable（）;
voidconvert（）;
voidmain（）;
3.2设计步骤：
设计一个矩阵类实现矩阵的运算：
classtripletable（包含矩阵的各种运算函数）。
输入矩阵（以三元组形式输入非零元）
{
intk;
tripletableA,B;
cout<
<
"
输入稀疏矩阵A的行数，列数和非零元个数：
;
cin>
>
A.m>
A.n>
A.t;
for（k=1;
k<
=A.t;
k++）
printf（"
输入第%d个非0元素的行数，列数和值:
k）;
A.data[k].i>
A.data[k].j>
A.data[k].v;
}
输出矩阵：
intc[100][100]={0};
=B.t;
c[B.data[k].i][B.data[k].j]=B.data[k].v;
转置（加法，乘法）结果为：
endl;
=B.n;
for（intl=1;
l<
=B.m;
l++）
c[k][l]<
"
转置矩阵：
voidtripletable:
:
convert（）//矩阵的转置
B.m=A.m;
B.n=A.n;
B.t=A.t;
if（B.t）
intq=1,col;
for（col=1;
col<
=A.n;
++col）
for（intp=1;
p<
++p）
if（A.data[p].j==col）
B.data[q].i=A.data[p].j;
B.data[q].j=A.data[p].i;
B.data[q].v=A.data[p].v;
++q;
intshuru[100][100]={0};
shuru[B.data[k].j][B.data[k].i]=B.data[k].v;
输入为：
shuru[k][l]<
intresult[100][100]={0};
result[B.data[k].i][B.data[k].j]=B.data[k].v;
结果为：
result[k][l]<
以上主要设计思想：
通过三元组输入一个矩阵A，为了找到A的每一列中所有非零元素，需要对其三元组表A.data从第一行起整个扫描一遍，由于A.data是以A的行序为主序来存放每个非零元的，由此得到的恰是B.data的应有的顺序。
加法矩阵：
add（）//矩阵的加法
输入稀疏矩阵B的行数，列数和非零元个数：
B.m>
B.n>
B.t;
B.data[k].i>
B.data[k].j>
B.data[k].v;
if（A.m!
=B.m||A.n!
=B.n）
输入错误：
A与B的行数或列数不相同，请重新输入"
return;
inta[100][100]={0};
a[A.data[k].i][A.data[k].j]=A.data[k].v;
A输入为：
=A.m;
a[k][l]<
intb[100][100]={0};
b[B.data[k].i][B.data[k].j]=B.data[k].v;
B输入为：
b[k][l]<
intc[100][100]={0};
c[k][l]=a[k][l]+b[k][l];
加法结果C为：
此功能由函数add（）实现，当用户选择该功能时系统即提示用户初始化要进行加法的两个矩阵的信息。
然后检测这两个矩阵是否符合矩阵相加的规则，如果符合，进行加法。
否则重新输入第二个矩阵来保证两个矩阵可以相加。
最后输出结果。
乘法矩阵：
multi（）//矩阵的乘法
tripletableA,B,C;
introw=1;
while（row<
=A.data[k].i）
A.rpos[row++]=k;
=A.m）A.rpos[row++]=A.t+1;
row=1;
=B.data[k].i）
B.rpos[row++]=k;
=B.m）B.rpos[row++]=B.t+1;
if（A.n!
=B.m）
A的列数不等于B的行数，请重新输入"
C.m=A.m;
C.n=B.n;
C.t=0;
intarow,p,q,ccol,t,tp;
if（A.t*B.t!
=0）
for（arow=1;
arow<
++arow）
intctemp[maxsize]={0};
C.rpos[arow]=C.t+1;
if（arow<
A.m）{tp=A.rpos[arow+1];
else{tp=A.t+1;
for（p=A.rpos[arow];
tp;
intbrow=A.data[p].j;
if（brow<
B.m）{t=B.rpos[brow+1];
else{t=B.t+1;
for（q=B.rpos[brow];
q<
t;
++q）
ccol=B.data[q].j;
ctemp[ccol]+=A.data[p].v*B.data[q].v;
for（ccol=1;
ccol<
=C.n;
++ccol）
if（ctemp[ccol]）
if（++C.t>
maxsize）return;
C.data[C.t].i=arow;
C.data[C.t].j=ccol;
C.data[C.t].v=ctemp[ccol];
}
inta[100][100]={0};
=C.t;
c[C.data[k].i][C.data[k].j]=C.data[k].v;
乘法结果C为：
=C.m;
以上主要设计思想为：
此功能由函数multi（）实现。
当用户选择该功能，系统提示输入要进行相乘的两个矩阵的详细信息。
然后检测两者是否可以相乘，如果不能，则重新初始化第二个矩阵。
先对矩阵B进行逐行处理，先求得累计求和的中间结果（C的每一行），然后再压缩存储到c.data中去，最后得到结果。
第四章设计理论分析方法
4.1算法一：
矩阵转置
转置运算时一种最简单的矩阵运算，对于一个m*n的矩阵M，他的转置矩阵T是一个n*m的矩阵，且T（i，j）=M（j，i），1<
=i<
=n,1<
=j<
=m。
显然，一个稀疏矩阵的转置矩阵仍然是稀疏矩阵。
（1）将矩阵的行列值相互交换;
（2）将每个三元组中的i和j相互调换；
（3）重排三元组之间的次序便可实现矩阵的转置。
一般矩阵转置算法为
for（col=1;
=nu;
for（row=1;
row<
=mu;
++row）
T[col][row]=M[row][col];
按照a.data中三元组的次序进行转置，并将转置后的三元组置入b中恰当的位置。
在此，需要附设num和cpot两个向量。
Num[col]表示矩阵M中第col列中非零元的个数，cpot[col]指示M中第col列的第一个非零元在b.data中的恰当位置。
cpot[1]=1
cpot[col]=cpot[col-1]+num[col-1]2<
=col<
=a.nu
这就是快速转置。
4.2算法二：
矩阵加法
稀疏矩阵使用三元组存储，则运算时只需考虑非零元的值即可。
两个矩阵相加
首先必须保证M.mu=N.mu&
&
M.nu=N.nu即同行同列的矩阵才能相加。
=M.tu;
for（i=1;
i<
=N.tu;
i++）
if（M.data[k].i==N.data[i].i&
M.data[k].j==N.data[i].j）
Q.data[count].e=M.data[k].e+N.data[i].e;
flag[i]=true;
如果非零元位置一样就直接相加
if（i>
N.tu）
Q.data[count].e=M.data[k].e;
如果没有找到与M非零元位置一样的元素就直接把M中的非零元赋值给矩阵Q。
for（k=1;
if（!
flag[k]）
Q.data[count].e=N.data[k].e;
如果N中的元素没有被查找，则直接把N中的非零元赋值给矩阵Q。
4.3算法三：
矩阵乘法
矩阵乘法采用“带行信息”的三元组存储。
经典算法如下：
for（i=1;
=m1;
++i）
for（j=1;
j<
=n2;
++j）
{Q[i][j]=0;
=n1;
++k）
Q[i][j]+=M[j][k]*N[k][j];
稀疏矩阵相乘前提：
M.nu=N.mu
大致步骤描述如下：
Q初始化；
If（Q是非零矩阵）
{//逐行求积
for（arow=1;
arrow<
=M.mu;
{//处理M的每一行
ctemp[]=0;
//累加器清零
计算Q中第arow行的积并存入ctemp[]中；
将ctemp[]中非零元压缩存储到Q.data;
}
第五章程序调试
整个程序主要运用了矩阵运算的规则，利用创建三元组表，分析数据，行列是否匹配，稀疏矩阵的转置，稀疏矩阵的相加，稀疏矩阵的相乘。
（1）稀疏矩阵的转置
图5.1
（2）稀疏矩阵的加法
图5.2
（3）稀疏矩阵的乘法：
图5.3
第六章心得体会
通过此次课程设计，使我更加扎实的掌握了有关稀疏矩阵方面的知识，在设计过程中虽然遇到了一些问题，但经过一次又一次的思考，一遍又一遍的检查终于找出了原因所在，也暴露出了前期我在这方面的知识欠缺和经验不足。
实践出真知，通过亲自动手制作，使我们掌握的知识不再是纸上谈兵。
过而能改，善莫大焉。
在课程设计过程中，不断发现错误，不断改正，不断领悟，不断获取。
最终的检测调试环节，本身就是在践行“过而能改，善莫大焉”的知行观。
这次课程设计终于顺利完成了，在设计中遇到了很多问题，最后在老师和同学的指导下，终于游逆而解。
在今后社会的发展和学习实践过程中，一定要不懈努力，不能遇到问题就想到要退缩，一定要不厌其烦的发现问题所在，然后一一进行解决，只有这样，才能成功的做成想做的事，才能在今后的道路上劈荆斩棘，而不是知难而退，那样永远不可能收获成功，收获喜悦，也永远不可能得到社会及他人对你的认可！
参考文献
[1]谭浩强著.C程序设计（第三版）[M].：
清华大学，2009.5
[2]严蔚敏、吴伟民主编《数据结构（C语言版）》[M].清华大学2004.11
[3]．建学等编著《数据结构课程设计案例精编（用C/C++描述）》[M]，清华大学2007.2
[4].殷人昆主编《数据结构:
用面向对象方法与C++语言描述》[M]，
清华大学2007.6
升级会员 