广工数据结构实验报告.docx

广工数据结构实验报告.docx

《广工数据结构实验报告.docx》由会员分享，可在线阅读，更多相关《广工数据结构实验报告.docx（41页珍藏版）》请在冰豆网上搜索。

广工数据结构实验报告

数据结构实验报告

题目：

稀疏矩阵

学院计算机学院

专业计算机科学与技术

年级班别2012级班

学号

学生姓名

指导教师

成绩____________________

2014年6月

1.题目：

抽象数据类型稀疏矩阵ADT定义如下：

ADT SparseMatrix{ 

    数据对象：

D={aij|i=1,2,...,m; j=1,2,...,n; 

               aij∈ElemSet, m 和n分别称为矩阵的行数和列数}    

 数据关系：

R={Row，Col} 

              Row={|1<=i<=m,1<=j<=n-1} 

Col={|1<=i<=m-1,1<=j<=n} 

    基本操作：

Status CreateSMatrix（TSMatrix &M） 

操作结果：

创建稀疏矩阵M 

Status DestroySMatrix（TSMatrix &M） 

初始条件：

稀疏矩阵M已经存在 

操作结果：

销毁矩阵M 

void PrintSMatrix（TSMatrix M） 

初始条件：

稀疏矩阵M已经存在 

操作结果：

打印矩阵M

Status CopySMatrix（TSMatrix M, TSMatrix &T） 

初始条件：

稀疏矩阵M已经存在 

操作结果：

复制矩阵M到T 

Status AddSMatrix（TSMatrix M, TSMatrix N, TSMatrix &Q） 

初始条件：

稀疏数组M、N的行数和列数对应相等 

操作结果：

求矩阵的和Q=M+N 

Status SubSMatrix（TSMatrix M, TSMatrix N, TSMatrix &Q） 

初始条件：

稀疏数组M、N的行数和列数对应相等 

操作结果：

求矩阵的差Q=M-N 

Status TransposeSMatrix（TSMatrix M, TSMatrix & T） 

初始条件：

稀疏数组M已经存在 

操作结果：

求矩阵M的转置T 

Status MultSMatrix（TSMatrix M, TSMatrix N, TSMatrix &Q） 

初始条件：

稀疏数组M的列数等于N的行数

操作结果：

求矩阵的积Q=M*N 

StatusFindElem（TSMatrixM,introw,intcol,ElemType&e）

初始条件：

稀疏数组M存在

操作结果：

查找第row行,第col列元素,若不为0则用e返回其值 

StatusInsertElem（TSMatrix&M,introw,intcol,ElemTypee）

初始条件：

稀疏数组M存在

操作结果：

在第row行，第col列位置插入元素e 

StatusDeleteElem（TSMatrix&M,introw,intcol,ElemType&e）

初始条件：

稀疏数组M存在

操作结果：

删除第row行，第col列元素 

StatusIsEmptyMatrix（TSMatrixM）

操作结果：

判断是否为空矩阵

}ADTSparseMatrix

2．存储结构定义

稀疏矩阵的三元组顺序表存储表示

#defineMAXSIZE50

typedefstruct{

inti,j;

ElemTypee;

}Triple;

typedefstruct{

Tripledata[MAXSIZE+1];

intmu,nu,tu;

}TSMatrix;

3.算法设计

#include

#include

#defineTRUE1;

#defineFALSE0;

#defineOK1

#defineERROR0;

typedefintStatus;

typedefintElemType;

/*稀疏矩阵的三元组顺序表存储表示*/

#defineMAXSIZE50

typedefstruct{

inti,j;

ElemTypee;

}Triple;

typedefstruct{

Tripledata[MAXSIZE+1];//这里可用数组实现也可用指针实现

intmu,nu,tu;

}TSMatrix;

//对三元组表示的稀疏矩阵进行排序

//需要排序是因为创建三元组时可以任意不按顺序输入

voidOrder（TSMatrix&M）{

inta,b;

Triplet;

for（a=1;a

for（b=a+1;b

if（M.data[a].i>M.data[b].i）{//如果前面一个行号比后面一//个行号大，就交换

t=M.data[a];

M.data[a]=M.data[b];

M.data[b]=t;

}

if（M.data[a].i==M.data[b].i）{//行号相等，列号大的在后面

if（M.data[a].j>M.data[b].j）{

t=M.data[a];

M.data[a]=M.data[b];

M.data[b]=t;

}

}

}

}

}

//

（1）销毁稀疏矩阵M

StatusDestroySMatrix（TSMatrix&M）{//要想销毁一个三元组表示的//矩阵就必须销毁四部分

intnum=M.tu;//M.mu,M.nu,M.tu和M.data[]

M.mu=0;

M.nu=0;

M.tu=0;

for（intk=1;k<=num;k++）{//因为用数组实现，又数组为静//态分配，故销毁数组只能置其内容为0

M.data[k].i=0;//而不能释放其空间

M.data[k].j=0;

M.data[k].e=0;

}

returnOK;

}

//

（2）创建稀疏矩阵M

StatusCreateSMatrix（TSMatrix&M）{

if（M.tu!

=0）//M如果非空

DestroySMatrix（M）;

intm,n,t,i,j,e;

intflag=0;//flag用来标志输入是否重复

printf（"请输入矩阵的行数、列数和非零元个数（格式为：

X,X,X）\n"）;

while

（1）{

scanf（"%d,%d,%d",&m,&n,&t）;

if（t<=0||m<=0||n<=0）{//输入的行列数要为正数

printf（"对不起，您输入有误！

请重新输入！

\n"）;

printf（"请输入矩阵的行数、列数和非零元个数（格式为：

X,X,X）\n"）;

}elseif（t>m*n）{//非零元个数不能大于矩阵最大个数

printf（"对不起，您输入的非零元个数不合理！

请重新输入！

\n"）;

printf（"请输入矩阵的行数、列数和非零元个数（格式为：

X,X,X）\n"）;

}else//输入正确

break;

}

M.mu=m;M.nu=n;M.tu=t;

printf（"请输入你想创建的稀疏矩阵:

（格式为：

X,X,X）\n"）;

for（intk=1;k<=M.tu;k++）{

scanf（"%d,%d,%d",&i,&j,&e）;

if（i>M.mu）{

printf（"输入有误,行号过大,请重新输入！

\n"）;

k--;

}elseif（i<=0）{

printf（"输入有误,行号必须为正数,请重新输入！

\n"）;

k--;

}elseif（j<=0）{

printf（"输入有误,列号必须为正数,请重新输入！

\n"）;

k--;

}elseif（j>M.nu）{

printf（"输入有误,列号过大,请重新输入！

\n"）;

k--;

}elseif（e==0）{

printf（"输入有误,值不能为零,请重新输入！

\n"）;

k--;

}else{

for（intt=1;t<=k;t++）{

if（i==M.data[t].i&&j==M.data[t].j）{

printf（"输入有误,您输入的下标重复,请重新输入！

\n"）;

k--;

flag=1;

break;

}

}

if（flag==0）{//输入完全正确情况下

M.data[k].i=i;

M.data[k].j=j;

M.data[k].e=e;

}

}

}

//对三元组表示的稀疏矩阵进行排序

Order（M）;

printf（"*矩阵已完成创建！

*\n"）;

returnOK;

}

//（3）输出稀疏矩阵M

voidPrintSMatrix（TSMatrixM）{

printf（"\t%d行%d列%d个元素\n",M.mu,M.nu,M.tu）;

printf（"\t-----------------\n"）;

printf（"\t%c\t%c\t%c\n",'i','j','e'）;

printf（"\t-----------------\n"）;

if（M.tu==0）//如果为空

printf（"\t这是一个空的矩阵\n"）;

else{

for（intk=1;k<=M.tu;k++）{

printf（"\t%d\t%d\t%d",M.data[k].i,M.data[k].j,M.data[k].e）;

printf（"\n"）;

}

}

printf（"\t-----------------\n\n"）;

}

//（4）查找稀疏矩阵M中，第row行，第col列元素，若不为0则用e返回其值

StatusFindElem（TSMatrixM,introw,intcol,ElemType&e）{

for（intk=1;k<=M.tu;k++）{

if（row==M.data[k].i&&col==M.data[k].j）{

e=M.data[k].e;

printf（"*%d行%d列元素%d已找到*\n",row,col,e）;

returnOK;

}

}//找不到

printf（"对不起，不存在此元素！

\n"）;

returnERROR;

}

//（5）在三元组表示的稀疏矩阵M，第row行，第col列位置插入元素e

StatusInsertElem（TSMatrix&M,introw,intcol,ElemTypee）{

inti,t,p;

if（row==0||col==0||e==0）{//插入值为0

printf（"对不起，插入元素值不能为0，操作失败！

\n"）;

returnERROR;

}

p=1;//标志新元素应该插入的位置

if（M.tu==0）{//插入前矩阵M为空矩阵,直接插入

M.data[p].i=row;

M.data[p].j=col;

M.data[p].e=e;

M.mu=row;

M.nu=col;

M.tu++;

printf（"*元素已插入！

*\n"）;

returnOK;

}

if（M.tu==M.mu*M.nu）{//当前三元组表已满

printf（"当前三元组表已满，操作失败！

\n"）;

returnERROR;

}

if（row>M.mu||col>M.nu||row<1||col<1）{//插入位置越界，//不在1~mu或1~nu之间

printf（"插入位置越界，请在此矩阵的行列数内操作。

操作失败！

\n"）;

returnERROR;

}

for（t=1;t<=M.tu;t++）{//寻找合适的插入位置

if（（row==M.data[t].i）&&（col==M.data[t].j））{//插入前，该位置元//素已经存在

printf（"*对不起，该位置已经有元素存在，操作失败！

*\n"）;

returnERROR;

}elseif（（row==M.data[t].i）&&（col>=M.data[t].j））

p++;

elseif（row>M.data[t].i）

p++;

}

for（i=M.tu;i>=p;i--）{//移动p之后的元素

M.data[i+1].i=M.data[i].i;

M.data[i+1].j=M.data[i].j;

M.data[i+1].e=M.data[i].e;

}

//插入新元素

M.data[p].i=row;

M.data[p].j=col;

M.data[p].e=e;

M.tu++;

printf（"*元素已插入！

*\n"）;

returnOK;

}

//（6）在稀疏矩阵M，删除第row行，第col列位置元素，并用e返回

StatusDeleteElem（TSMatrix&M,introw,intcol,ElemType&e）{

intt,p=0;

if（M.tu==0）{//矩阵如果为空

printf（"操作失败！

这是个空矩阵！

\n"）;

returnERROR;

}

if（row>M.mu||col>M.nu||row<1||col<1）{//删除位置越界，不在1~mu//或1~nu之间

printf（"删除位置越界，请在此矩阵的行列数内操作。

操作失败！

\n"）;

returnERROR;

}

for（t=1;t<=M.tu;t++）{//寻找合适的删除位置

if（（row==M.data[t].i）&&（col==M.data[t].j））

p=t;

}

if（p==0）{

printf（"删除失败，不存在此元素！

\n"）;

returnERROR;

}else{

e=M.data[p].e;

for（;p

M.data[p].i=M.data[p+1].i;

M.data[p].j=M.data[p+1].j;

M.data[p].e=M.data[p+1].e;

}

M.data[p].i=0;//把最后一个元素置为0

M.data[p].j=0;

M.data[p].e=0;

}

M.tu--;

printf（"*%d行%d列元素%d已删除*\n",row,col,e）;

returnOK;

}

//（7）判断是否为空矩阵

StatusIsEmptyMatrix（TSMatrixM）{

if（M.tu==0）{

printf（"*这是一个空矩阵！

*\n"）;

}else

printf（"*这是一个非空矩阵！

*\n"）;

returnOK;

}

//（8）由稀疏矩阵M复制得到T

StatusCopySMatrix（TSMatrixM,TSMatrix&T）{

if（T.tu!

=0）//原来T为非空

DestroySMatrix（T）;

T.mu=M.mu;

T.nu=M.nu;

T.tu=M.tu;

for（intk=1;k<=M.tu;k++）{

T.data[k].i=M.data[k].i;

T.data[k].j=M.data[k].j;

T.data[k].e=M.data[k].e;

}

returnOK;

}

//（9）求和Q=M+N

StatusAddSMatrix（TSMatrixM,TSMatrixN,TSMatrix&Q）{

ElemTypet;

intk=1,a,b;//a,b记下已经访问了几个

intflag[50];//flag用来标志N表中哪个数据已经用过

if（Q.tu!

=0）//原来Q为非空

DestroySMatrix（Q）;

if（M.tu==0）{

CopySMatrix（N,Q）;

printf（"*矩阵已完成相加！

*\n"）;

returnOK;

}elseif（N.tu==0）{

CopySMatrix（M,Q）;

printf（"*矩阵已完成相加！

*\n"）;

returnOK;

}

if（M.mu!

=N.mu||M.nu!

=N.nu）{

printf（"对不起，两个矩阵的行列号大小不相等不能相加！

\n"）;

returnERROR;

}

Q.mu=M.mu;Q.nu=M.nu;

a=0;b=0;

for（intx=1;x<=49;x++）

flag[x]=0;

for（intp1=1;p1<=M.tu;p1++）{

for（intp2=1;p2<=N.tu;p2++）{

if（M.data[p1].i==N.data[p2].i）{//行号相等

if（M.data[p1].j==N.data[p2].j）{//且列号相等

flag[p2]=1;//为1表示此数据已经用过

a++;b++;//M，N访问数各加1

t=M.data[p1].e+N.data[p2].e;

if（t!

=0）{//和为非零，插入

Q.data[k].i=M.data[p1].i;

Q.data[k].j=M.data[p1].j;

Q.data[k].e=t;

k++;

break;

}else

break;

}

else{//行号相等，列号不等，把列号小的插入

if（M.data[p1].j

Q.data[k].i=M.data[p1].i;

Q.data[k].j=M.data[p1].j;

Q.data[k].e=M.data[p1].e;

flag[p2]=0;

k++;a++;

break;

}elseif（flag[p2]==0）{//N表中此数据还没访问//过且列号小，插入

Q.data[k].i=N.data[p2].i;

Q.data[k].j=N.data[p2].j;

Q.data[k].e=N.data[p2].e;

flag[p2]=1;

k++;b++;

}

}

}

else{//行号不等，把行号小的插入

if（M.data[p1].i

Q.data[k].i=M.data[p1].i;

Q.data[k].j=M.data[p1].j;

Q.data[k].e=M.data[p1].e;

a++;k++;

break;

}

elseif（flag[p2]==0）{

Q.data[k].i=N.data[p2].i;

Q.data[k].j=N.data[p2].j;

Q.data[k].e=N.data[p2].e;

flag[p2]=1;

k++;b++;

}

}

}

}

if（a

while（a

Q.data[k].i=M.data[a+1].i;

Q.data[k].j=M.data[a+1].j;

Q.data[k].e=M.data[a+1].e;

k++;a++;

}

}elseif（b

while（b

Q.data[k].i=N.data[b+1].i;

Q.data[k].j=N.data[b+1].j;

Q.data[k].e=N.data[b+1].e;

k++;b++;

}

}

Q.tu=k-1;

printf（"*矩阵已完成相加！

*\n"）;

returnOK;

}

//（10）求差Q=M-N

StatusSubSMatrix（TSMatrixM,TSMatrixN,TSMatrix&Q）{

ElemTypet;

intk=1,a,b;//a,b记下已经访问了几个

intflag[50];//用来标志N表中哪个数据已经用过

if（Q.tu!

=0）//原来Q为非空

DestroySMatrix（Q）;

if（M.tu==0）{//被减数为空

CopySMatrix（N,Q）;

for（intk=1;k<=N.tu;k++）

Q.data[k].e=-Q.data[k].e;//变为负的

printf（"*矩阵已完成相减！

*\n"）;

returnOK;

}elseif（N.tu==0）{//减数为空

CopySMatrix（M,Q）;

printf（"*矩阵已完成相减！

*\n"）;

returnOK;

}

if（M.mu!

=N.mu||M.nu!

=N.nu）{

printf（"对不起，两个矩阵的行列号大小不相等不能相减！

\n"）;

returnERROR;

}

Q.mu=M.mu;Q.nu=M.nu;

a=0;b=0;

for（intx=1;x<=49;x++）

flag[x]