数据结构实验四字符串稀疏矩阵实验.docx
《数据结构实验四字符串稀疏矩阵实验.docx》由会员分享，可在线阅读，更多相关《数据结构实验四字符串稀疏矩阵实验.docx（17页珍藏版）》请在冰豆网上搜索。
数据结构实验四字符串稀疏矩阵实验
实验编号：
4四川师大《数据结构》实验报告2016年11月12日
实验四字符串、稀疏矩阵实验_
一．实验目的及要求
（1）熟悉字符串类型的实现方法，并完成串的一些基本操作；
（2）掌握稀疏矩阵的三元组顺序表存储表示，并实现矩阵的转置运算。
二．实验内容
（1）编程实现两个串S1和S2的比较。
（要求自己设计串的存储结构，并编写比较函数，不要调用系统提供的函数）
（2）编程实现稀疏矩阵的三元组顺序表示方法及基本操作的实现（建立、输出、转置等）。
（3）编程实现稀疏矩阵的十字链表存储表示及基本操作的实现（建立、输出等）。
注：
（2）必做，
（1）（3）选做。
三．主要仪器设备及软件
（1）PC机
（2）DevC++,VisualC++,VS2010等
四．实验主要流程、基本操作或核心代码、算法片段（该部分如不够填写，请另加附页）
（1）编程实现两个串S1和S2的比较。
（要求自己设计串的存储结构，并编写比较函数，不要调用系统提供的函数）
Ø代码部分：
//Main.cpp:
#include"SString.h"
intmain（）
{
SStringT1,T2;
inti,n;
T1[0]=T2[0]=0;
cout<<"inputT1size:
";
cin>>n;
T1[0]=n;
cout<<"inputT1data:
";
for（i=1;i<=n;i++）
{
cin>>T1[i];
}
cout<<"inputT2size:
";
cin>>n;
T2[0]=n;
cout<<"inputT2data:
";
for（i=1;i<=n;i++）
{
cin>>T2[i];
}
cout<<"T1"<return0;
}
//SString.cpp:
#include"SString.h"
charCompare（SStringT1,SStringT2）
{
if（T1[0]>T2[0]）
{
return'>';
}
elseif（T1[0]{
return'<';
}
else
{
for（inti=1;i<=T1[0];i++）
{
if（T1[i]>T2[i]）
{
return'>';
}
elseif（T1[i]{
return'<';
}
}
}
return'=';
}
//SString.h:
#include
usingnamespacestd;
constintMAX=255;
typedefunsignedcharSString[MAX+1];
charCompare（SStringT1,SStringT2）;
Ø运行结果：
（2）编程实现稀疏矩阵的三元组顺序表示方法及基本操作的实现（建立、输出、转置等）。
Ø代码部分：
//Main.cpp
#include"TSMatrix.h"
intmain（）{
TSMatrixT,M;
intcount;
cout<<"输入矩阵的行数，列数，非零元个数：
";
cin>>M.mu>>M.nu>>M.tu;
for（count=1;count<=M.tu;count++）
{
cout<<"请输入第"<cin>>M.data[count].i>>M.data[count].j>>M.data[count].e;
}
TransposeSMatrix（M,T）;
cout<<"ije"<for（count=1;count<=T.tu;count++）
{
cout<}
return0;
}
//TSMatrix.cpp
#include"TSMatrix.h"
StatusTransposeSMatrix（TSMatrixM,TSMatrix&T）{
intcol,p,q;
T.mu=M.nu;T.nu=M.mu;T.tu=M.tu;
if（T.tu）{
q=1;
for（col=1;col<=M.nu;++col）
{
for（p=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;
}
}
}
}
returnOK;
}
//TSMatrix.h
#include
usingnamespacestd;
constintMAXSIZE=12500;
constintOK=1;
constintERROR=0;
typedefintElemType;
typedefintStatus;
typedefstruct{
inti,j;
ElemTypee;
}Triple;
typedefstruct{
Tripledata[MAXSIZE+1];
intmu,nu,tu;
}TSMatrix;
StatusTransposeSMatrix（TSMatrixM,TSMatrix&T）;
Ø运行结果：
（3）编程实现队列在两种存储结构中的基本操作（队列的初始化、判队列空、入队列、出队列）。
Ø代码部分：
A:
链式储存：
//Main.cpp:
#include"QNode.h"
intmain（）{
LinkQueueQ;
InitQueue（Q）;
Menu（Q）;
DestroyQueue（Q）;
return0;
}
//QNode.cpp:
#include"QNode.h"
StatusInitQueue（LinkQueue&Q）{
//构造空队列
Q.front=Q.rear=（QueuePrt）malloc（sizeof（QNode））;
if（!
Q.front）exit（ERROR）;
Q.front->next=NULL;
returnOK;
}
StatusDestroyQueue（LinkQueue&Q）{
//销毁队列Q
while（Q.front）{
Q.rear=Q.front->next;
free（Q.front）;
Q.front=Q.rear;
}
returnOK;
}
StatusEnQueue（LinkQueue&Q,QElemTypee）{
//插入元素a为Q的新的队尾元素
QNode*p;
p=（QueuePrt）malloc（sizeof（QNode））;
if（!
p）exit（ERROR）;
p->data=e;p->next=NULL;
Q.rear->next=p;
Q.rear=p;
returnOK;
}
StatusDeQueue（LinkQueue&Q,QElemType&e）{
//删除Q的队头元素，用e返回其值
QNode*p;
if（Q.front==Q.rear）returnERROR;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if（Q.rear==p）Q.rear=Q.front;
free（p）;
returnOK;
}
StatusQueueEmpty（LinkQueueQ）{
//判断对是否为空
if（Q.front==Q.rear）returnERROR;
returnOK;
}
voidMenu（LinkQueue&Q）{
//输出选择界面
intselect=1;
QElemTypee;
while（select）{
cout<<"--------------------"<cout<<"请选择以下功能：
"<cout<<"--------------1,入队"<cout<<"--------------2,出队"<cout<<"--------------3,判断队空"<cout<<"--------------0,退出程序"<cout<<"请输入你的选择";
cin>>select;
switch（select）{
case0:
break;
case1:
cout<<"输入入队数据"<cin>>e;
if（EnQueue（Q,e））{
cout<<"入队成功"<}
break;
case2:
if（DeQueue（Q,e））{
cout<}
break;
case3:
if（QueueEmpty（Q））cout<<"此队不为空"<elsecout<<"此队为空"<break;
}
}
}
//QNode.h
#ifndefQNODE_H
#defineQNODE_H
#include
#include
usingnamespacestd;
constintOK=1;
constintERROR=0;
typedefintQElemType;
typedefintStatus;
typedefstructQNode{
QElemTypedata;
structQNode*next;
}QNode,*QueuePrt;
typedefstruct{
QueuePrtfront;
QueuePrtrear;
}LinkQueue;
StatusInitQueue（LinkQueue&Q）;//构造空队列
StatusDestroyQueue（LinkQueue&Q）;//销毁队列Q
StatusEnQueue（LinkQueue&Q,QElemTypee）;//插入元素a为Q的新的队尾元素
StatusDeQueue（LinkQueue&Q,QElemType&e）;//删除Q的队头元素，用e返回其值
StatusQueueEmpty（LinkQueueQ）;//判断对是否为空
voidMenu（LinkQueue&Q）;//输出选择界面
#endif
Ø运行结果：
B顺序存储:
Ø代码部分：
//main.cpp:
#include"SqQueue.h"
intmain（）{
SqQueueQ;
if（InitQueue（Q））{
cout<<"创建队成功"<Menu（Q）;
DestroyQueue（Q）;
}
return0;
}
//SqQueue.cpp:
#include"SqQueue.h"
StatusInitQueue（SqQueue&Q）{
//创建空队列
Q.base=（QElemType*）malloc（MAXSIZE*sizeof（QElemType））;
if（!
Q.base）exit（ERROR）;
Q.front=Q.rear=0;
returnOK;
}
StatusEnQueue（SqQueue&Q,QElemTypee）{
//插入元素e为Q的新队尾元素
if（（（Q.rear+1）%MAXSIZE）==Q.front）returnERROR;
Q.base[Q.rear]=e;
Q.rear=（Q.rear+1）%MAXSIZE;
returnOK;
}
StatusDeQueue（SqQueue&Q,QElemType&e）{
//删除Q的对头元素，用e返回其值。
if（Q.front==Q.rear）returnERROR;
e=Q.base[Q.front];
Q.front=（Q.front+1）%MAXSIZE;
returnOK;
}
StatusSqQueueEmpty（SqQueueQ）{
//判断Q是否为空
if（Q.front==Q.rear）returnERROR;
returnOK;
}
StatusDestroyQueue（SqQueue&Q）{
//销毁栈
Q.front=Q.rear=0;
free（Q.base）;
returnOK;
}
voidMenu（SqQueue&Q）{
//输出选择菜单
intselect=1;
QElemTypee;
while（select）{
cout<<"----------------------------------"<cout<<"请选择一下功能:
"<cout<<"1，入队"<cout<<"2，出队"<cout<<"3，判断是否为空"<cout<<"0，退出程序"<cout<<"你的选择是：
";
cin>>select;
switch（select）{
case0:
break;
case1:
cout<<"输入插入的数据:
";
cin>>e;
if（EnQueue（Q,e））{
cout<<"入队成功"<}
elsecout<<"队满"<break;
case2:
if（DeQueue（Q,e））{
cout<}
elsecout<<"队空"<break;
case3:
if（SqQueueEmpty（Q））{
cout<<"队未空"<}
elsecout<<"队空"<break;
}
}
}
//SqQueue.h:
#ifndefSQQUEUE_H
#defineSQQUEUE_H
#include
#include
usingnamespacestd;
constintMAXSIZE=100;
constintMORE=100;
constintOK=1;
constintERROR=0;
typedefintQElemType;
typedefintStatus;
typedefstruct{
QElemType*base;
intfront;
intrear;
}SqQueue;
StatusInitQueue（SqQueue&Q）;//创建空队列
StatusEnQueue（SqQueue&Q,QElemTypee）;//插入元素e为Q的新队尾元素
StatusDeQueue（SqQueue&Q,QElemType&e）;//删除Q的对头元素，用e返回其值。
StatusSqQueueEmpty（SqQueueQ）;//判断Q是否为空
StatusDestroyQueue（SqQueue&Q）;//销毁栈
voidMenu（SqQueue&Q）;//输出选择菜单
#endif
Ø运行结果：
（3）编程实现稀疏矩阵的十字链表存储表示及基本操作的实现（建立、输出等）。
Ø代码部分：
//CrossList.h
#include
#include
#defineOK1;
#defineERROR1;
typedefintElemType;
typedefintStatus;
typedefstructOLNode{
inti,j;
ElemTypee;
structOLNode*right,*down;
}OLNode,*OLink;
typedefstruct{
OLink*rhead,*chead;
intmu,nu,tu;
}CrossList;
StatusCreateSMatrix_OL（CrossList&M）;
//CrossList.cpp
#include"CrossList.h"
StatusCreateSMatrix_OL（CrossList&M）{
intm,n,t,i,j,e,k;
OLNode*p,*q;
//if（M）free（M）;
printf（"mu,nu,tu:
"）;
scanf（"%d%d%d",&m,&n,&t）;
M.mu=m;M.nu=n;M.tu=t;
M.rhead=（OLink*）malloc（（m+1）*sizeof（OLink））;
if（!
M.rhead）returnERROR;
if（!
（M.chead=（OLink*）malloc（（n+1）*sizeof（OLink））））returnERROR;
for（k=1;k<=M.mu;k++）M.rhead[k]=NULL;
for（k=1;k<=M.nu;k++）M.chead[k]=NULL;
printf（"inputije:
"）;
for（scanf（"%d%d%d",&i,&j,&e）;i!
=0;scanf（"%d%d%d",&i,&j,&e））{
p=（OLNode*）malloc（sizeof（OLink））;
if（!
p）returnERROR;
p->i=i;p->j=j;p->e=e;
if（M.rhead[i]==NULL||M.rhead[i]->j>j）{
p->right=M.rhead[i];M.rhead[i]=p;}
else{
for（q=M.rhead[i];（q->right）&&q->right->jright）;
p->right=q->right;q->right=p;}
if（M.chead[j]==NULL||M.chead[j]->i>i）{
p->down=M.chead[j];M.chead[j]=p;}
else{
for（q=M.chead[j];（q->down）&&q->down->idown）;
p->down=q->down;q->down=p;}
printf（"inputije:
"）;
}
returnOK;
}
//main.cpp
#include"CrossList.h"
intmain（）{
CrossListM;
OLNode*q;
CreateSMatrix_OL（M）;
printf（"ije\n"）;
for（inti=1;i<=M.nu;i++）{
if（M.chead[i]!
=NULL）
{
q=M.chead[i];
while（q）
{
printf（"%5d%5d%5d\n",q->i,q->j,q->e）;
q=q->down;
}
}
}
return0;
}
Ø运行结果：
五．实验结果的分析与评价（该部分如不够填写，请另加附页）
1.稀疏矩阵的存储比较难理解。
储存过程较为复杂，但是用与各种计算时比较方便。
注：
实验成绩等级分为（90－100分）优，（80－89分）良，（70-79分）中，（60－69分）及格，（59分）不及格。
升级会员 