数据结构课程设计.docx
《数据结构课程设计.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计.docx（32页珍藏版）》请在冰豆网上搜索。
数据结构课程设计
实习1线性表及其应用
1．集合的并、交和差
/******************************************************
【实验目的】
编制一个能演示执行集合的并、交和差运算的程序
【实验任务】
1）集合的元素限定为小写字母；
2）演示程序以用户和计算机的对话方式执行。
【概要设计】
intInitlist（linklist&L）{}用来初始化线性链表
voidmakenode（linklist&L,chare）{}生成结点
intxiaoxie（chare,intflag）{}判断输入的字符是否是小写字母
voidjiao（linklist&L,linklistm,linklistn）{}求两个集合的交
voidbing（linklist&L,linklistm,linklistn）{}求两个集合的并
voidcha（linklist&L,linklistm,linklistn）{}求两个集合的交
****************************************************************/
//c.cpp:
Definestheentrypointfortheconsoleapplication.
//
/*****【程序代码】******/
#include"stdafx.h"
#include"malloc.h"
#include"iostream.h"
typedefcharelemtype;
#defineTRUE1;
#defineFALSE0;
typedefstructlnode//单链表存储结构
{
elemtypedata;
structlnode*next;
}lnode,*linklist;
intInitlist（linklist&L）//初始化线性链表
{
L=（linklist）malloc（sizeof（lnode））;
if（!
L）returnFALSE;
L->next=NULL;
returnTRUE;
}
voidmakenode（linklist&L,chare）//生成结点
{
linklists;
s=（linklist）malloc（sizeof（lnode））;
s->data=e;
s->next=L->next;
L->next=s;
}
intxiaoxie（chare,intflag）//判断输入的字符是否是小写字母
{
if（（e<'a'）||（e>'z'））
{
printf（"输入错误!
必须为小写字母!
\n"）;
flag=0;
}
returnflag;
}
voidjiao（linklist&L,linklistm,linklistn）//求两个集合的交，并且将其存入另一个链表中
{
linklistp;
Initlist（p）;
while（m->next）
{
p=n;//使每次循环从n的第一个结点开始
while（p->next）
{
if（m->next->data==p->next->data）
{
makenode（L,m->next->data）;//有相等元素是将元素放入链表中跳出循环
break;
}
p=p->next;
}
m=m->next;
}//while
}
voidbing（linklist&L,linklistm,linklistn）//求两个集合的并，并且存入一个链表中
{
linklistJ;
Initlist（J）;
jiao（J,m,n）;//利用上面所求的两个集合的交进行下一步运算
linklistp;
while（m->next）//先将其中一个集合的的元素存入链表
{
makenode（L,m->next->data）;
m=m->next;
}
while（n->next）//再将另一个集合中不同于前一个集合的元素存入此链表中
{
p=J;
while（p->next）
{
if（n->next->data==p->next->data）
break;//当有相同元素时跳出循环
p=p->next;
}//while
if（!
p->next）
makenode（L,n->next->data）;
n=n->next;
}//while
}
voidcha（linklist&L,linklistm,linklistn）//利用两集合的交J,将第一个集合中的与J不同的元素放入链表
{
linklistJ;
Initlist（J）;
jiao（J,m,n）;//求交
linklistp;
while（m->next）
{
p=J;
while（p->next）
{
if（m->next->data==p->next->data）
break;//当在交中有相同元素时，跳出循环
p=p->next;
}//while
if（!
p->next）
makenode（L,m->next->data）;
m=m->next;
}//while
}
intmain（intargc,char*argv[]）
{
chara[50],b[50];//将两个数组的元素存入链表中
inti;
intflag=1;
cout<<"输入第一个集合A:
";
cin>>a;//使两个集合中的元素全部限定为小写字母
for（i=0;*（a+i）!
='\0'&&flag;i++）
flag=xiaoxie（*（a+i）,flag）;
cout<<"输入第二个集合B:
";
cin>>b;
for（i=0;*（a+i）!
='\0'&&flag;i++）
flag=xiaoxie（*（a+i）,flag）;
if（flag==0）//如果输入不是小写字母则报错并终止
{
cout<<"不能继续执行交并差的运算!
";
return0;
}
linklistm,n;
Initlist（m）;
Initlist（n）;
for（i=0;*（a+i）!
='\0';i++）
makenode（m,*（a+i））;
for（i=0;*（b+i）!
='\0';i++）
makenode（n,*（b+i））;
linklistJ,B,C;//J,B,C分别为两集合的交,并,差
//初始化链表，并且分别对其操作
Initlist（J）;
Initlist（B）;
Initlist（C）;
jiao（J,m,n）;
bing（B,m,n）;
cha（C,m,n）;
linklistp;//以下为输出集合，并释放存储空间
cout<<"两个集合的交是:
";
p=J;
while（p->next）
{
cout<next->data;
p=p->next;
}
cout<cout<<"两个集合的并是:
";
p=B;
while（p->next）
{
cout<next->data;
p=p->next;
}
cout<cout<<"两个集合的差A-B是:
";
p=C;
while（p->next）
{
cout<next->data;
p=p->next;
}
cout<while（m->next!
=NULL）
{
p=m;
m=m->next;
free（p）;
}
while（n->next）
{
p=n;
n=n->next;
free（p）;
}
while（J->next）
{
p=J;
J=J->next;
free（p）;
}
while（B->next）
{
p=B;
B=B->next;
free（p）;
}
while（C->next）
{
p=C;
C=C->next;
free（p）;
}
return0;
}
/****************************
【测试数据及结果分析】
第一组的测试数据为
wsxjt
wbxt
结果
输入第一个集合A:
wsxjt
输入第二个集合B:
wbxt
两个集合的交是:
wxt
两个集合的并是:
bwsxjt
两个集合的差A-B是:
sj
第二组的测试数据为
ASD
ACD
结果
输入第一个集合A:
ASD
输入错误!
必须为小写字母!
输入第二个集合B:
ACD
不能继续执行交并差的运算!
本程序可以较好的完成集合的交并差运算,
将集合的元素限定为小写字母.
******************************/
实习2栈、队列和递归程序设计
1.求算术表达式的值。
/***************************************************************
【实验目的】
设计一个程序，演示用算符优先法对算术表达式求值的过程。
【实验任务】
以字符序列的形式从终端输入以'#'结束表达式。
如果表达式正确计算
表达式的值否则指出表达式中错误的类型。
在输入的表达式中可以有
加、减、乘、除和括号运算，输入的数据为实数。
输出表达式的值，
并且输出在求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。
【概要设计】
voidInitStack（SqStack&S）//栈的初始化
voidPush（SqStack&S,chare）//插入栈数据
voidPop（SqStack&S,char&e）//删除头结点,并返回值
charGetTop（SqStackS）//返回栈顶元素
intIn（charc）//限定运算符
charPrecede（chara,charb）//判断运算符的优先级
****************************************************************/
/*****【程序代码】******/
#include"stdafx.h"
#include"malloc.h"
#include"iostream.h"
#defineSTACK_INIT_SIZE100
#defineSTACKINCREMENT10
typedefstruct{//栈结点
char*base;
char*top;
intstacksize;
}SqStack;
voidInitStack（SqStack&S）//栈的初始化
{
S.base=（char*）malloc（STACK_INIT_SIZE*sizeof（char））;
if（!
S.base）
cout<<"Error1!
"<else
{S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
}
}
voidPush（SqStack&S,chare）//插入栈数据
{
if（S.top-S.base>=S.stacksize）
{
S.base=（char*）realloc（S.base,（S.stacksize+STACKINCREMENT）*sizeof（char））;
if（!
S.base）
cout<<"Error2!
"<else
{S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
}
*S.top++=e;
}
voidPop（SqStack&S,char&e）//删除头结点,并返回值
{
if（S.top==S.base）
cout<<"Error3!
"<else
e=*--S.top;
}
charGetTop（SqStackS）//返回栈顶元素
{
if（S.top==S.base）
cout<<"Error4!
"<else
return*（S.top-1）;
}
intIn（charc）//限定运算符
{
switch（c）
{
case'）':
case'#':
case'+':
case'-':
case'*':
case'/':
case'（':
return1;break;
default:
return0;
}
}
charPrecede（chara,charb）//判断运算符的优先级
{
intt=-1;
if（a=='）'&&b!
='（'）
t=1;
if（（a=='*'||a=='/'）&&b!
='（'）
t=1;
if（（a=='+'||a=='-'）&&（b=='+'||b=='-'||b=='）'||b=='#'））
t=1;
if（（a=='（'&&b=='）'）||（a=='#'&&b=='#'））
t=1;
if（（a=='（'&&b=='）'）||（a=='#'&&b=='#'））
t=0;
switch（t）
{
case1:
return'>';break;
case-1:
return'<';break;
case0:
return'=';break;
}
}
charOperate（chara,chart,charb）//运算符的运算
{
switch（t）
{
case'+':
returna+b-'0';break;
case'-':
returna-b+'0';break;
case'*':
return（a-'0'）*（b-'0'）+'0';break;
case'/':
return（a-'0'）/（b-'0'）+'0';break;
default:
cout<<"Error5!
"<}
}
intmain（）
{
SqStackOPTR,OPND;
chara,b,c,x,theta;
InitStack（OPTR）;
Push（OPTR,'#'）;
InitStack（OPND）;
cout<<"请输入表达式:
"<c=getchar（）;
while（c!
='#'||GetTop（OPTR）!
='#'）
{
if（!
In（c））
{
Push（OPND,c）;
c=getchar（）;
}
else
{
switch（Precede（GetTop（OPTR）,c））
{
case'<':
Push（OPTR,c）;
c=getchar（）;
break;
case'=':
Pop（OPTR,x）;
c=getchar（）;
break;
case'>':
Pop（OPTR,theta）;
Pop（OPND,b）;
Pop（OPND,a）;
Push（OPND,Operate（a,theta,b））;
break;
}
}
}
cout<<"Result="<<（GetTop（OPND）-'0'）<return0;
}
/****************************
【测试数据及结果分析】
测试数据为
1+3*4+（9/3）-5#
结果
请输入表达式:
1+3*4+（9/3）-5#
result=11
本程序通过栈的运用完成了
加、减、乘、除和括号的运算
******************************/
实习3数组和广义表
1.三元组表示的稀疏矩阵的转置、加法和乘法的实现。
/***************************************************************
【实验目的】
编制一个能演示执行集合的并、交和差运算的程序
【实验任务】
（1）演示稀疏矩阵A的三元组和十字链表的建立过程。
（2）演示稀疏矩阵A的转置过程。
（3）演示稀疏矩阵A和B的相加过程。
（4）演示稀疏矩阵A和B的相乘过程。
【概要设计】
voidStoreRpos（RLSMtrix&M）//用于存储
voidFastTransportRLS（RLSMtrixM,RLSMtrix&T）//实现矩阵的转置
voidCreateRLSMtrix（RLSMtrix&M）//创建矩阵用于矩阵的乘法与转置
boolMulSMatrix（RLSMtrixM,RLSMtrixN,RLSMtrix&Q）//矩阵的乘法运算
voidPrintRLSMatrix（RLSMtrixA）//矩阵的输出
boolCreateSMatrix_OL（CrossList&M）//创建矩阵用于矩阵的加法
voidTranslate（charc）//确定矩阵进行的运算
voidPrintCrossList（CrossListA）//输出矩阵的值
****************************************************************/
/*****【程序代码】******/
#include"stdafx.h"
#include"malloc.h"
#include"iostream.h"
#defineMAXSIZE100
#defineMAXRC10
#defineNUM10
typedefstruct{
inti,j;
inte;
}Triple;
typedefstruct{
Tripledata[MAXSIZE+1];
intrpos[MAXRC+1];
intmu,nu,tu;
}RLSMtrix;
typedefstructOLNode{
inti,j;
inte;
structOLNode*right,*down;
}OLNode,*OLink;
typedefstruct{
OLinkrhead,chead;
intmu,nu,tu;
}CrossList;
voidStoreRpos（RLSMtrix&M）//用于存储
{
intnum[NUM]={0};
intt;
if（M.tu）
{
for（t=1;t<=M.tu;t++）
++num[M.data[t].i];
M.rpos[1]=1;
for（t=2;t<=M.nu;++t）
M.rpos[t]=M.rpos[t-1]+num[t-1];
}
}
voidFastTransportRLS（RLSMtrixM,RLSMtrix&T）//实现矩阵的转置
{
intp,q,col;
T.mu=M.nu;
T.nu=M.mu;
T.tu=M.tu;
if（T.tu）
{
for（p=1;p<=M.tu;++p）
{
col=M.data[p].i;
q=M.rpos[col];
T.data[q].i=M.data[p].j;
T.data[q].j=M.data[p].i;
T.data[q].e=M.data[q].e;
++M.rpos[col];
}
StoreRpos（T）;
}
}
voidCreateRLSMtrix（RLSMtrix&M）//创建矩阵用于矩阵的乘法与转置
{
intt;
cout<<"请输入mu,nu,tu:
"<cin>>M.mu>>M.nu>>M.tu;
cout<<"请输入非零元:
"<for（t=1;t<=M.tu;t++）
cin>>M.data[t].i>>M.data[t].j>>M.data[t].e;
StoreRpos（M）;
}
boolMulSMatrix（RLSMtrixM,RLSMtrixN,RLSMtrix&Q）//矩阵的乘法运算
{
intarrow,p,q,t,tp,brow,col;
if（M.nu!
=N.mu）
returnfalse;
Q.mu=M.mu;
Q.nu=N.nu;
Q.tu=0;
if（M.tu*N.tu!
=0）
{
for（arrow=1;arrow<=M.mu;arrow++）
{
intctemp[NUM]={0};
Q.rpos[arrow]=Q.tu+1;
if（arrowtp=M.rpos[arrow+1];
else
tp=M.tu+1;
for（p=M.rpos[arrow];p{
brow=M.data[p].j;
if（browt=N.rpos[brow+1];
else
t=N.tu+1;
for（q=N.rpos[brow];q{
col=N.data[q].j;
ctemp[col]+=M.data[p].e*N.data[q].e;
}
}
for（col=1;col<=Q.nu;++col）
{
if（ctemp[col]）
{
if（++Q.tu>MAXSIZE）
returnfalse;
Q.data[Q.tu].i=arrow;
Q.data[Q.tu].j=col;
Q.data[Q.tu].e=ctemp[col];
}
}
}
}
returntrue;
}
voidPrintRLSMatrix（RLSMtrixA）//矩阵的输出
{
inta[NUM][NUM]={0};
升级会员 