软件实习报告.docx
《软件实习报告.docx》由会员分享，可在线阅读，更多相关《软件实习报告.docx（48页珍藏版）》请在冰豆网上搜索。
软件实习报告
计算机科学与技术专业
软件实习1
课程名:
课程号：
学号：
姓名：
三、内容
1、集合的并、交和差运算
（一）设计题目
【问题描述】编制一个能演示执行集合的并、交和差运算的程序。
【基本要求】
（1）集合的元素限定为小写字母字符[‘a’..’z’]。
（2）演示程序以用户和计算机的对话方式执行。
【实现提示】以链表表示集合。
【选作内容】
（1）集合的元素判定和子集判定运算。
（2）求集合的补集。
（3）集合的混合运算表达式求值。
（4）集合的元素类型推广到其他类型，甚至任意类型。
（二）需求分析
set（）//建立只有头结点的空链表
set（chara[],intm）;//建立有m个元素的单链表
set（constset&s）;
intis_notin（charc）;//确定位置
voidsort（）;//排序
voidinsert（charc）;//插入结点
voidprint（）;//遍历
~set（）;//析构函数
（3）概要设计
输入的只能是小写字母
交运算：
查找B集合中与A集合中相同的元素，插入到C集合中。
并运算：
先将A集合中的元素插入到C集合中，然后查找B集合中与A集合中不相同的元素，插入到C集合中。
差运算：
比较A集合与B集合中的元素，找出在A集合中且不在B集合中的元素，插入到C集合中。
（4）详细设计
#include
#include
usingnamespacestd;
structNode{//定义结点
chardata;
Node*next;
};
classset{
public:
set（）//建立只有头结点的空链表
{
first=newNode;
first->next=NULL;
}
set（chara[],intm）;//建立有m个元素的单链表
set（constset&s）;
intis_notin（charc）;
voidsort（）;//排序
voidinsert（charc）;//插入结点
voidprint（）;//遍历
~set（）;
Node*first;
};
set:
:
set（chara[],intm）
{
m=strlen（a）;
first=newNode;//头插法
first->next=NULL;
for（inti=0;i{
Node*p=newNode;
p->data=a[i];
p->next=first->next;
first->next=p;
}
}
set:
:
~set（）//析构函数
{
while（first!
=NULL）
{
Node*p=first;
first=first->next;
deletep;
}
}
voidset:
:
sort（）
{
for（Node*p=first->next;p->next!
=NULL;p=p->next）
for（Node*q=p->next;q!
=NULL;q=q->next）
if（q->datadata）
{
chart=q->data;
q->data=p->data;
p->data=t;
}
}
voidset:
:
insert（charc）
{
Node*p=newNode;
p->data=c;
p->next=first->next;
first->next=p;
}
set:
:
set（constset&s）
{
first=newNode;
first->next=NULL;
Node*p=s.first->next;
while（p!
=NULL）
{
Node*q=newNode;
q->data=p->data;
q->next=first->next;
first->next=q;
p=p->next;
}
}
intset:
:
is_notin（charc）
{
Node*p=first->next;
while（p）
{
if（p->data==c）return0;
p=p->next;
}
return1;
}
voidset:
:
print（）
{
Node*p=first->next;
while（p!
=NULL）
{
cout<data<<'\t';
p=p->next;
}
cout<}
setjiaoji（seta,setb）
{
a.sort（）;
b.sort（）;
sett;
Node*p=a.first->next;
Node*q=b.first->next;
while（p!
=NULL&&q!
=NULL）
{
if（p->datadata）p=p->next;
elseif（q->datadata）q=q->next;
else{
t.insert（p->data）;
p=p->next;
q=q->next;
}
}
returnt;
}
setbingji（seta,setb）
{a.sort（）;
b.sort（）;
sett;
Node*p=a.first->next;
Node*q=b.first->next;
while（p!
=NULL&&q!
=NULL）
{
if（p->datadata）{t.insert（p->data）;p=p->next;}
elseif（q->datadata）{t.insert（q->data）;q=q->next;}
else{
t.insert（p->data）;
p=p->next;
q=q->next;
}
}
if（p!
=NULL）
{
while（p!
=NULL）
{
t.insert（p->data）;
p=p->next;
}
}
if（q!
=NULL）
{
while（q!
=NULL）
{
t.insert（q->data）;
q=q->next;
}
}
returnt;
}
setchaji（seta,setb）
{sett;
Node*p=a.first->next;
while（p!
=NULL）
{
if（b.is_notin（p->data））t.insert（p->data）;
p=p->next;
}
returnt;
}
intmain（）
{
intn;
chars1[100];
cout<<"请正确输入集合s1:
"<cin.getline（s1,100）;
chars2[100];
cout<<"请正确输入集合s2:
"<cin.getline（s2,100）;
setS1（s1,n）,S2（s2,n）;
cout<<"输入的第一个集合为：
"<S1.print（）;
cout<<"输入的第二个集合为：
"<S2.print（）;
cout<<"两个集合的交集为：
"<cout<<"s1∩s2=";
jiaoji（S1,S2）.print（）;
cout<<"两个集合的并集为：
"<cout<<"s1∪S2=";
bingji（S1,S2）.print（）;
cout<<"两个集合的差集为：
"<cout<<"s1-s2=";
chaji（S1,S2）.print（）;
return0;
}
2、病人就医管理
（一）设计题目
【问题描述】病人到医院看病，排队看医生的情况，在病人排队过程中，主要发生两件事：
（1）病人到达诊室，将病历本交给护士，排到等待队列中候诊。
（2）护士从等待队列中取出一位病人的病历，该病人进入诊室就诊。
试为医院编制按上述要求进行管理的模拟程序。
【基本要求】程序采用菜单方式，其选项及功能说明如下：
（1）排队------输入病人的病历号，加入到病人排队队列中
（2）就诊-------病人排队队列中最前面的病人就诊，并将其从队列中删除。
（3）查看排队------从队首到队尾列出所有的排队病人的病历号。
（4） 下班---------退出运行。
（2）需求分析
char*number;
patient（）;//无参构造函数
patient（char*num）;//带参构造函数
patient（constpatient&per）;//拷贝构造函数
~patient（）;//折构函数
voiddisplay（）;//显示病人病历
voidinput（）;//输入病人病历
（3）概要设计
采用队列的数据结构，先进先出，排队时入队，就诊时出队。
队空时，k==count+1，此时可以下班。
（四）详细设计
#include
#include
usingnamespacestd;
classpatient//定义病人这一个类
{//病历号
public:
char*number;
patient（）;//无参构造函数
patient（char*num）;//带参构造函数
patient（constpatient&per）;//拷贝构造函数
~patient（）;//折构函数
voiddisplay（）;//显示病人病历
voidinput（）;//输入病人病历
};
patient:
:
patient（）
{
number=NULL;
}
patient:
:
patient（char*num）
{
if（num）
{
number=newchar[strlen（num）+1];//避免浅拷贝,将病历号拷贝
strcpy（number,num）;
}
}
patient:
:
patient（constpatient&per）//拷贝构造函数
{
if（per.number）
{
number=newchar[strlen（per.number）+1];
strcpy（number,per.number）;
}
}
patient:
:
~patient（）//折构函数
{
if（number）
delete[]number;
}
voidpatient:
:
display（）//输出病人病历号
{
cout<<"病历号:
"<}
voidpatient:
:
input（）//输入病人病历号
{
charnum[10];
cout<<"输入病历号:
";
cin>>num;
if（number）delete[]number;
number=newchar[strlen（num）+1];//数组'/0'
strcpy（number,num）;//
}
constintN=10;
voidOutput（patient*a）;
voidInput（patient*a）;
intjiuzhen（patient*a）;
intchakanpaidui（patient*a）;
voidend（patient*a）;
intcount=0,k=1,z=10;
voidInput（patient*a）//俩个
{
a[count].input（）;
count++;
z--;
cout<<"还有"<<（z）<<"名排队等待名额"<}
intjiuzhen（patient*a）
{
if（k<=count）
{
cout<<"请"<"<k++;
z++;//有人就诊，增加一排队名额
cout<<"还有"<<（z）<<"排队等待名额"<}
else
cout<<"现在没有病人救诊!
"<return0;
}
intchakanpaidui（patient*a）
{
if（k==count+1）
{
cout<<"现在没有病人排队!
"<}
else
{
cout<<"正在排队中的病人:
"<for（inti=k-1;ia[i].display（）;
}
return0;
}
intend（）
{
if（k==count+1）
{
cout<<"可以下班了!
"<return0;
}
else
{
cout<<"还有病人，不可以下班!
"<return1;
}
}
intmain（）
{
patienta[N];//定义病人数组
intchoice;//读入选项
cout<<"病人就医管理"<cout<<"你好，欢迎登陆病人管理系统!
"<cout<<"1.排队--输入病人的病历号，加入到病人的排队队列中。
"<cout<<"2.就诊--病人排队队列中最前面的病人就诊，并将其从队列中删除。
"<cout<<"3.参看排队--从队首到队尾列出所有的排队病人的病历号。
"<cout<<"4.下班?
"<cout<<"5.结束调试。
"<cout<cout<<"医院排队区仅限10人"<do
{
cout<<"请选择:
";
cin>>choice;
if（choice>0&&choice<=5）
switch（choice）
{
case1:
Input（a）;
break;
case2:
jiuzhen（a）;
break;
case3:
chakanpaidui（a）;break;
case4:
end（）;break;
}
else
{
cout<<"输入错误，请重新输入!
"<}
cout<}while（choice!
=5）;
return0;
}
3、校园导游咨询
（一）设计题目
【问题描述】设计一个校园导游程序，为来访的客人提供各种信息查询服务。
【基本要求】
（1）设计学校的校园平面图，所含景点不少于10个，以图中顶点表示校内各景点，存放景点名称、代号、简介等信息；以边表示路径，存放路径长度等相关信息。
（2）为来访客人提供图中任意景点相关信息的查询。
（3）为来访客人提供景点的问路查询，即已知一个景点，查询到某景点之间的一条最短路径及长度。
（二）需求分析
Grahp（inte[vertexNum][vertexNum],intv[vertexNum]）;//初始化图的邻接矩阵
intshortest_way（ints,intd）;//求最短路径
intBFS（ints,intd）;//广度优先算法
（三）概要设计
伪代码：
1.初始化数组dist，path和s；
2.While（s中的元素个数2.1在dist[n]中求最小值，其编号为K；
2.2输出dist[k]和path[k];
2.3修改数组dist和path;
2.4将顶点k添加到数组s中；
（四）详细设计
#include
usingnamespacestd;
constintmaxsize=10;
constintMAX=10000;
intdefault_e[maxsize][maxsize]={0,100,150,MAX,100,400,MAX,MAX,MAX,MAX,
100,0,MAX,MAX,MAX,MAX,MAX,MAX,MAX,400,
150,MAX,0,100,MAX,MAX,50,MAX,MAX,MAX,
MAX,MAX,100,0,MAX,MAX,MAX,200,100,200,
100,MAX,MAX,MAX,0,250,MAX,MAX,MAX,MAX,
400,MAX,MAX,MAX,250,0,100,300,MAX,MAX,
MAX,MAX,50,MAX,MAX,100,0,MAX,MAX,MAX,
MAX,MAX,MAX,200,MAX,300,MAX,0,150,MAX,
MAX,MAX,MAX,100,MAX,MAX,MAX,150,0,150,
MAX,400,MAX,200,MAX,MAX,MAX,MAX,150,0};
intdefault_v[maxsize]={0,1,2,3,4,
5,6,7,8,9};
structview_spot_node{
charname[maxsize];
intcodename;
view_spot_nodeoperator=（view_spot_node&v）
{
codename=v.codename;
for（inti=0;iname[i]=v.name[i];
returnv;
}
};
view_spot_nodedefault_vsn[maxsize]={"景点A",1,
"景点B",2,
"景点C",3,
"景点D",4,
"景点E",5,
"景点F",6,
"景点G",7,
"景点H",8,
"景点I",9,
"景点J",10};
classGrahp{
public:
Grahp（inte[maxsize][maxsize],intv[maxsize]=default_v）;
intshortest_way（ints,intd）;
intstore_v[maxsize];
intdistance[maxsize];
private:
intBFS（ints,intd）;
voidstore（intd）;
intedge[maxsize][maxsize];
intvertex[maxsize];
intq[maxsize];
intstate[maxsize][maxsize];
intprevious[maxsize];
};
Grahp:
:
Grahp（inte[maxsize][maxsize],intv[maxsize]）
{
for（inti=0;i{
vertex[i]=v[i];
for（intj=0;jedge[i][j]=e[i][j];
}
}
intGrahp:
:
shortest_way（ints,intd）
{
for（inti=0;i{
q[i]=0;
distance[i]=MAX;
previous[i]=i;
store_v[i]=0;
for（intj=0;j{
if（edge[i][j]!
=MAX&&edge[i][j]!
=0）
state[i][j]=1;
elsestate[i][j]=0;
}
}
distance[s]=0;
BFS（s,d）;
store（d）;
returndistance[d];
}
intGrahp:
:
BFS（ints,intd）
{
if（s==d）return0;
intk;
intleft=maxsize;
while（left--）{
intmin=MAX;
for（inti=0;i{
if（q[i]==0&&distance[i]{
min=distance[i];
k=i;
}
}
q[k]=1;
if（k==d）return0;
for（intj=0;j{
intdis=distance[k]+edge[k][j];
if（state[k][j]&&distance[j]>dis）
{
distance[j]=dis;
previous[j]=k;
}
}
}
return0;
}
voidGrahp:
:
store（intd）
{
staticintnum=0;
if（d==previous[d]）
{
//cout<store_v[num++]=d+1;
return;
}
store（previous[d]）;
store_v[num++]=d+1;
//cout<}
classcampus_guide:
publicGrahp{
public:
campus_guide（inte[maxsize][maxsize]=default_e,view_spot_nodev[maxsize]=default_vsn）;
voidguide（ints,intd）;
private:
view_spot_nodeview_spot[maxsize];
};
campus_guide:
:
campus_guide（inte[maxsize][maxsize],view_spot_nodev[maxsize]）
:
Grahp（e）
升级会员 