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