稀疏矩阵的操作课程设计Word格式.docx

稀疏矩阵的操作课程设计Word格式.docx

《稀疏矩阵的操作课程设计Word格式.docx》由会员分享，可在线阅读，更多相关《稀疏矩阵的操作课程设计Word格式.docx（19页珍藏版）》请在冰豆网上搜索。

一台计算机。

②软件配置：

WINDOWS、VC++6.0。

3系统功能设计及数据结构设计

3.1模块设计

本程序包含1个模块：

主程序模块加各功能实现模块。

3.2系统子程序及功能设计

本系统共设置7个子程序，各子程序的函数名及功能说明如下。

（1）typedefintElemType 

//初始化矩阵

（2）voidCreat（TSMatrix&

M） 

//建立矩阵

（3）voidPrint_SMatrix（TSMatrixM） 

//输出矩阵的信息

以下编号（4）-（6）是稀疏矩阵的基本操作。

依次是：

相加，相乘，转置等。

（4）voidXiangjia（TSMatrixA,TSMatrixB,TSMatrix&

C,intn）

//把A和B两个矩阵相加，结果是C

（5）voidXiangcheng（TSMatrixA,TSMatrixB,TSMatrix&

Q）

//把A和B两个矩阵相乘，结果是Q

（6）voidZhuanzhi（TSMatrix*a,TSMatrix*b） 

//把A转置

（7）voidmain（）

//主函数。

设定界面的颜色,大小和窗口的标题，调用工作区模块函数 

4算法设计、数据流图及程序结构框图

4.1程序功能模块

为了实现以上功能，可以从3个方面着手设计。

1．主界面设计

为了实现对稀疏矩阵的多种算法功能的管理，首先设计一个含有多个菜单项的主控菜单子程序以链接系统的各项子功能，方便用户交互式使用本系统。

2．存储结构设计

本系统采用单链表结构存储稀疏矩阵的具体信息。

其中：

全部结点的信息用头结点为指针数组的单链表存储。

3．系统功能设计

本系统除了要完成稀疏矩阵的初始化功能外还设置了4个子功能菜单。

稀疏矩阵的初始化由函数itypedefintElemType 

实现。

建立稀疏矩阵用voidCreat（）实现，依据读入的行数和列数以及非零元素的个数，分别设定每个非零元素的信息。

4个子功能的设计描述如下。

（1）稀疏矩阵的加法：

此功能由函数voidXiangjia（）实现，当用户选择该功能，系统即提示用户初始化要进行加法的两个矩阵的信息。

然后进行加法，最后输出结果。

（2）稀疏矩阵的乘法：

此功能由函数voidXiangcheng（）实现。

当用户选择该功能，系统提示输入要进行相乘的两个矩阵的详细信息。

然后进行相乘，最后得到结果。

（3）稀疏矩阵的转置：

此功能由函数voidZhuanzhi（）实现。

当用户选择该功能，系统提示用户初始化一个矩阵，然后进行转置，最终输出结果。

（4）退出：

即退出稀疏矩阵的应用系统。

由函数5实现，但用户选择此功能时，系统会提示你是否确实想退出，如果是，则退出，否则继续。

4.2程序流程图

5程序原代码及其说明

#include<

stdio.h>

malloc.h>

stdlib.h>

#defineMAXSIZE40//假设非零元素个数的最大值为40

#defineMAXRC20//假设矩阵的最大行数为20

typedefintElemType;

typedefstruct

{

inti,j;

//非零元的行下标和列下标

ElemTypee;

//非零元的值

}Triple;

Tripledata[MAXSIZE+1];

intrpos[MAXRC+1];

//各行第一个非零元在三元组的位置表

inths,ls,fls;

}TSMatrix,*Matrix;

voidCreat（TSMatrix&

M）

inti,k;

for（i=1;

i<

=MAXRC+1;

i++）

M.rpos[i]=0;

printf（"

请输入矩阵的行数、列数和非零元个数（以空格隔开）:

"

）;

scanf（"

%d%d%d"

&

M.hs,&

M.ls,&

M.fls）;

=M.fls;

i++）

{

printf（"

请用三元组形式输入矩阵的元素（行列非零元素）:

scanf（"

M.data[i].i,&

M.data[i].j,&

M.data[i].e）;

}

for（i=1,k=1;

=M.hs;

{

M.rpos[i]=k;

while（M.data[k].i<

=i&

&

k<

=M.fls）

k++;

}

}

voidXiangjia（TSMatrixA,TSMatrixB,TSMatrix&

inta,b,temp,l;

C.hs=A.hs;

C.ls=A.ls;

a=b=l=1;

while（a<

=A.fls&

b<

=B.fls）

if（A.data[a].i==B.data[b].i）

{

if（A.data[a].j<

B.data[b].j）

C.data[l++]=A.data[a++];

elseif（A.data[a].j>

{C.data[l]=B.data[b];

C.data[l++].e=n*B.data[b++].e;

}

else{

temp=A.data[a].e+n*B.data[b].e;

if（temp）

{

C.data[l]=A.data[a];

C.data[l].e=temp;

l++;

}

a++;

b++;

}

}

elseif（A.data[a].i<

B.data[b].i）

else{C.data[l]=B.data[b];

=A.fls）

C.data[l++]=A.data[a++];

while（b<

{C.data[l]=B.data[b];

C.fls=l-1;

intXiangcheng（TSMatrixA,TSMatrixB,TSMatrix&

intarow,brow,ccol,tp,p,q,t;

intctemp[MAXRC+1];

if（A.ls!

=B.hs）return0;

Q.hs=A.hs;

Q.ls=B.ls;

Q.fls=0;

if（A.fls*B.fls）

for（arow=1;

arow<

=A.hs;

arow++）

{

for（ccol=1;

ccol<

=Q.ls;

ccol++）

ctemp[ccol]=0;

Q.rpos[arow]=Q.fls+1;

if（arow<

A.hs）tp=A.rpos[arow+1];

elsetp=A.fls+1;

for（p=A.rpos[arow];

p<

tp;

p++）

{

brow=A.data[p].j;

if（brow<

B.hs）t=B.rpos[brow+1];

elset=B.fls+1;

for（q=B.rpos[brow];

q<

t;

q++）

{

ccol=B.data[q].j;

ctemp[ccol]+=A.data[p].e*B.data[q].e;

}

}

ccol++）

if（ctemp[ccol]）{

if（++Q.fls>

MAXSIZE）return0;

Q.data[Q.fls].i=arow;

Q.data[Q.fls].j=ccol;

Q.data[Q.fls].e=ctemp[ccol];

}

}

return1;

voidPrint_SMatrix（TSMatrixM）

intk,l,n;

Matrixp;

p=&

M;

for（k=1,n=1;

k<

=p->

hs;

k++）

for（l=1;

l<

ls;

l++）

if（p->

data[n].i==k&

p->

data[n].j==l）

printf（"

%5d"

p->

data[n].e）;

n++;

else

0）;

\n"

voidZhuanzhi（TSMatrix*a,TSMatrix*b）

{

intq,col,p;

b->

hs=a->

ls=a->

fls=a->

fls;

if（b->

fls）

q=1;

for（col=1;

col<

=a->

col++）

for（p=1;

if（a->

data[p].j==col）

b->

data[q].i=a->

data[p].j;

data[q].j=a->

data[p].i;

data[q].e=a->

data[p].e;

++q;

voidDestory_SMatrix（TSMatrix&

M）

M.hs=M.ls=M.fls=0;

voidmain（）

TSMatrixA,B,C;

TSMatrix*p=&

A,*q=&

B;

intflag,n;

while（true）

system（"

cls"

\n\n\n"

\t┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n"

\t┃***稀疏矩阵的加、转、乘***┃\n"

\t┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫\n"

\t┃1、稀疏矩阵的加法┃\n"

\t┃2、稀疏矩阵的转置┃\n"

\t┃3、稀疏矩阵的乘法┃\n"

\t┃4、退出该应用程序┃\n"

\t┃By陈强计算机科学与技术┃\n"

\t┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n"

输入要进行的项目的编号:

%d"

flag）;

if（flag==4）break;

Creat（A）;

矩阵A:

Print_SMatrix（A）;

switch（flag）

case1:

Creat（B）;

n=1;

printf（"

矩阵B:

Print_SMatrix（B）;

if（A.hs==B.hs&

A.ls==B.ls）

{

printf（"

A+B:

Xiangjia（A,B,C,n）;

Print_SMatrix（C）;

elseprintf（"

错误!

行列不一致\n"

break;

case2:

A->

B:

Zhuanzhi（p,q）;

Print_SMatrix（B）;

case3:

A*B:

n=Xiangcheng（A,B,C）;

if（!

n）printf（"

行列不匹配\n"

elsePrint_SMatrix（C）;

default:

输入错误!

Destory_SMatrix（A）;

Destory_SMatrix（B）;

Destory_SMatrix（C）;

getchar（）;

getchar（）;

\n\t\t\t***程序已经退出***\n"

getchar（）;

6程序测试及运行结果说明

由需求分析可知，稀疏矩阵的操作程序设计是在VC++6.0实现环境下全过程演示。

本程序已调试成功并实现了其功能。

其运行结果如下：

图6.1系统主界面：

图6.2.1运行加法运算：

图6.2.2运行加法运算：

图6.3.1运行乘法运算：

图6.3.2运行乘法运算：

图6.4运行矩阵转置运算：

图6.5系统退出界面：

7总结

总通过本次实验，在我的学习理解上有很大的促进作用。

单单对稀疏矩阵，我了解了由于矩阵在程序中常使用二维阵列表示，二维阵列的大小稀疏矩阵与使用的存储器空间成正比，如果多数的元素没有数据，则会造成存储器空间的浪费，为此，必须设计稀疏矩阵的阵列储存方式，利用较少的存储器空间储存完整的矩阵数据。

二维数组Amn中有N个非零元素，若N<

<

m*n,则称A为稀疏矩阵。

由于稀疏矩阵中含有很多的0元素,在计算机中存储会浪费很多的空间,因此我们通常采用压缩存储的方法。

主要参考资料

［1］《数据结构》（C语言版），严蔚敏，清华大学出版社，2003．

［2］《数据结构题集》，严蔚敏，清华大学出版社，2005．

［3］《数据结构》（C语言版），刘大有，高等教育出版社，2004．

［4］《DataStructurewithC++》，WilliamFord．WilliamTopp，清华大学出版社，2003．