数据结构实习报告.docx
《数据结构实习报告.docx》由会员分享，可在线阅读，更多相关《数据结构实习报告.docx（24页珍藏版）》请在冰豆网上搜索。
数据结构实习报告
数据结构上机实习报告
学校：
中国地质大学（武汉）
专业：
数学与应用数学
班级：
121142
姓名：
陈佳龙
完成时间：
2017.12.14
第一部分
停车场模拟
1.1问题描述
我们要模拟一个停车场的管理系统。
问题中有一个停车场，由于其可以停泊的车辆数量有限，为满足需求，我们有一个辅助的变道，一旦有车要停泊，我们便判断停车场的停车位是否已满，如果满了的话，就将其停泊在便道上。
实际的要求是不但有进，亦有出。
这就涉及到两个问题：
其一是我们要对从停车场驶出的车进行收费，这就涉及到其在停车场停留的时间计算。
通常情况下，我们会在总的入口（也就是出口）处设立收费站，有一辆车出现，我们首先会判断这辆车要入还是要出，如果是要入，我们就把当前时刻与该车对应起来。
如果该车是出来的（为简化问题，我们假设便道的车不许驶出，故驶出的车定是从停车场出来的），那么它必然已有一个时刻与之对应，我们只要用当前时刻减去该已有时刻，就是该车在停车场停留时间了。
其二是从停车场要出来车，就要后进入停车场的车给其暂时让位，为了使得该车驶离后其余车仍保持原来的顺序，我们需要一个辅助的堆栈。
事实上，该堆栈最满停车的数量为停车场停车位的数量减去一，我们在实际操作中让其与停车场堆栈的大小相同，这样就不用在定义一个堆栈结构了。
事实上，对于每从停车场驶出一辆车，就会有一个停车位空出，这时就要便道上的一辆车驶入停车场（如果便道上有车的话），我们对其开始计时。
那么，给他对应的时刻是多少呢？
事实上，驶出停车场的车会过收费站（程序输入端），会有一个当前时刻，我们只要将该时刻与要从便道驶入停车场的车从新对应就行了。
这就说明对每辆车开始收费的时刻并不一定是到“达的时刻”，而是要看该车是入停车场还是入便道，对于入便道的车，们还要修改其时刻，应为对于如便道的车，其“到达时刻”是没有实际意义的。
1.2基本要求
1以栈模拟停车场，以队列模拟车场外的便道。
2：
按照从终端读入的输入数据序列进行模拟管理。
3：
每一组输入数据包括三个数据项；汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时刻，对每一组输入数据进行操作后的输出数据为：
若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。
4：
栈以顺序结构实现，队列以链表结构实现。
1.3数据结构
//车结构体
typedefstructcar
{
inttag;//设置标志位，如果车辆到达tag==1,如果车辆tag==-1
longintcarID;//车牌号
floattime;//到达或离开的时刻，
}DataType;
//停车场堆栈，定义其大小即停车位个数为4
typedefstruct
{
DataTypestack[maxsizestack];//我们会将maxsizestack固定为4
inttop;
}SeqStack;
//便道队列节点
typedefstructqnode
{
DataTypedata;
structqnode*next;
}LQNode;
//便道队列
typedefstruct
{
LQNode*front;
LQNode*rear;
intcount;
}LQueue;
1.4测试数据
我们为了竟可能对所建模型进行测试，共设计了四组测试数据：
1.3.1第一组测试数据：
Test[3]={
{1,10001,10},
{1,10002,20},
{1,10003,30}
}
从终端输入的数据为：
11000440
说明：
test[3]表示已经有三辆车从终端（大门口）近去了，它们的车牌号依次为：
10001,10002,10003.到达时刻以此为10,20,30.现在有一辆车10004从大门口进入，我们要该系统对其做出反应。
1.3.2第二组测试数据
Test[3]={
{1,10001,10},
{1,10002,20},
{1,10003,30}
}
终端输入数据为：
-11000240
说明：
test[3]表示已经有三辆车从终端（大门口）近去了，它们的车牌号依次为：
10001,10002,10003.到达时刻以此为10,20,30.这与第一组测试数据相同，不同之处在于：
现有一辆车牌号为10002的车要离开，我们要该系统对其做出反应。
1.3.3第三组测试数据
Test[3]={
{1,10001,10},
{1,10002,20},
{1,10003,30}
}
从终端输入的数据为：
-11000440
数明：
test[3]表示已经有三辆车从终端（大门口）近去了，它们的车牌号依次为：
10001,10002,10003.到达时刻以此为10,20,30.这与第一，二组测试数据相同，不同之处在于：
现有一辆车牌号为10004的车显示的是离开，我们要该系统对其作出反应。
1.3.4第四组测试数据
Test[4]={
{1,10001,10},
{1,10002,20},
{1,10003,30},
{1,10004,40}
}
从终端输入数据为11000550
说明：
test[4]表示已经有四辆车从大门口进入（终端读入），现在有一辆车牌为10005的车要从大门口进入，需要该系统做出反应。
1.4模块划分
1：
PARK.h文件,定义堆栈的数据结构，初始化，判断堆栈是否为空，入栈，出栈操作。
队列的数据结构，包括队列的定义，初始化，入队列，出队列操作。
2：
StackDelete.h文件：
创建停车场内的任意一辆车的出堆栈函数voidStackDelete（SeqStack*S,longintcarID,float*tt），参数分别为该堆栈的指针和该车辆的车牌号carID,输出值为该车辆进入停车场时的时间。
3：
PARK.cpp文件，包括主函数。
1.6源程序
/**********************************************PARK.h文件*****************************************/
#include"malloc.h"
typedefstructcar
{
inttag;//设置标志位，如果车辆到达tag==1,如果车辆离开tag==-1
longintcarID;//车牌号
floattime;//到达或离开的时刻
}DataType;
#definemaxsizestack4
typedefstruct
{
DataTypestack[maxsizestack];
inttop;
}SeqStack;
/*****************初始化函数StackInitiate（SeqStack*S）**/
voidStackInitiate（SeqStack*S）
{
S->top=0;
}
/****************判空函数StackNotEmpty（SeqStackS）******/
intStackNotEmpty（SeqStackS）
{
if（S.top<=0）return（0）;
elsereturn1;
}
/****************判满函数StackNotFull（SeqStackS）*******/
intStackNotFull（SeqStackS）
{
if（S.top>=maxsizestack）return0;
elsereturn1;
}
/******入堆栈StackPush（SeqStack*S,DateTypex）**********/
intStackPush（SeqStack*S,DataTypex）
{
if（S->top>=maxsizestack）
{
printf（"堆栈以满，无法插入\n"）;
return0;
}
else
{
S->stack[S->top]=x;
S->top++;
return1;
}
}
/********出堆栈函数StackPop（SeqStack*S,DateType*d）*/
intStackPop（SeqStack*S,DataType*d）
{
if（S->top<=0）
{
printf（"堆栈以空无数据元素可出!
\n"）;
return0;
}
else
{
S->top--;
*d=S->stack[S->top];
return1;
}
}
/*********************LQueue**************************/
typedefstructqnode
{
DataTypedata;
structqnode*next;
}LQNode;
typedefstruct
{
LQNode*front;
LQNode*rear;
intcount;
}LQueue;
/***************初始化QueueInitiate（LQueue*Q）*******/
voidQueueInitiate（LQueue*Q）
{
Q->front=NULL;
Q->rear=NULL;
Q->count=0;
}
/**************队列判空QueueNotEmpty（LQueueQ）******/
intQueueNotEmpty（LQueueQ）
{
if（Q.front==NULL）return0;
elsereturn1;
}
/******入队列QueueAppend（LQueue*Q,DataTypex）******/
voidQueueAppend（LQueue*Q,DataTypex）
{
LQNode*p;
p=（LQNode*）malloc（sizeof（LQNode））;
p->data=x;
p->next=NULL;
if（Q->rear!
=NULL）Q->rear->next=p;
Q->rear=p;
if（Q->front==NULL）Q->front=p;
Q->count++;
}
/******出队列QueueDelete（LQueue*Q,DataType*d）******/
intQueueDelete（LQueue*Q,DataType*d）
{
LQNode*p;
if（Q->front=NULL）{
printf（"队列为空"）;
return0;
}
else
{
*d=Q->front->data;
p=Q->front;
Q->front=Q->front->next;
if（Q->front==NULL）Q->rear=NULL;
free（p）;
Q->count--;
return1;
}
}
/*****************************************StackDelete.h文件*****************************************/
/*创建停车场内的任意一辆车的出堆栈函数，参数分别为该堆栈的
指针和该车辆的车牌号carID,输出值为该车辆进入停车场时的时间*/
voidStackDelete（SeqStack*S,longintcarID,float*tt）
{
intn=S->top;//记下未出堆栈S时堆栈内元素的个数
SeqStackT;//创建辅助堆栈
DataTypex;
StackInitiate（&T）;//初始化辅助堆栈T
while（StackNotEmpty（*S））
{
StackPop（S,&x）;
if（x.carID!
=carID）StackPush（&T,x）;
/*依次将堆栈S中的元素出堆栈，若该元素不是要找的元素，将其压入堆栈T中*/
else
{
*tt=x.time;
break;
}
}
/*若该元素是要找的元素，返回该元素的time改时间是其入堆栈S时的时间*/
while（StackNotEmpty（T））
{
StackPop（&T,&x）;
StackPush（S,x）;
}
/*将T中的元素还给S*/
if（S->top==n）*tt=0;//如果此时栈顶指针的位置没有变换，说明S中没有该车牌号的车辆
}
/**********************************************PARK.CPP文件***************************************/
#include
#include"PARK.h"
#include"malloc.h"
//typedefCarDataType;//将抽象数据具体化
#definemaxsizestack4//停车场的容量为4
#include”StackDelete.h”
#definee1//停车场单位时间的收费为e=1
//为第一组，第二组，第三组测试数据编的主函数
voidmain（）
{
SeqStackS1;
floatt;//定义停车场堆栈S1，停车场辅助堆栈S2；
float*tt=&t;
LQueueQ;//定义变道队列Q
DataTypeca1,ca2;//定义数据
StackInitiate（&S1）;//初始化S1；
QueueInitiate（&Q）;//初始化Q；
DataTypetest[3]={
{1,10001,10},
{1,10002,20},
{1,10003,30}
};/*定义测试数据*/
for（inti=0;i<3;i++）
{
StackPush（&S1,test[i]）;
}/*测试数据入堆栈*/
scanf（"%d%ld%f",&ca1.tag,&ca1.carID,&ca1.time）;//输入车辆ca1的信息
/*对到达的车辆的处理*/
if（ca1.tag==1）
{
if（StackNotFull（S1））
{
printf（"该车停于停车场S1的第%d个停车位\n",S1.top）;
StackPush（&S1,ca1）;
}
else
{
printf（"该车停于便到的第%d个位置\n",Q.count）;
QueueAppend（&Q,ca1）;
}
}
else
{
StackDelete（&S1,ca1.carID,tt）;//调用StackDelete函数，将车辆ca1出停车场，并将其进入停车场是的时刻赋给t
if（t）
{
t=ca1.time-t;//如果该车辆是从停车场内开出的，将停留时间重新赋给t
if（QueueNotEmpty（Q））
{
QueueDelete（&Q,&ca2）;
ca2.time=ca1.time;
StackPush（&S1,ca2）;
}
/*如果此时变车道上有车辆的话记作ca2将其辆驶入停车场，
将其time改ca1离开时的time,即从ca1离开时对ca2开始计时*/
}
elset=0;//若该车辆不是从停车场开出的，显然其停留时间为
printf（"该车停留的时间t=%f,应收取的费用为money=%f\n",t,t*e）;
}
}
//为第四组数据编的主函数
voidmain（）
{
SeqStackS1;
floatt;//定义停车场堆栈S1，停车场辅助堆栈S2；
float*tt=&t;
LQueueQ;//定义变道队列Q
DataTypeca1,ca2;//定义数据
StackInitiate（&S1）;//初始化S1；
QueueInitiate（&Q）;//初始化Q；
DataTypetest[4]={
{1,10001,10},
{1,10002,20},
{1,10003,30},
{1,10004,40},
};/*定义测试数据*/
for（inti=0;i<4;i++）
{
StackPush（&S1,test[i]）;
}/*测试数据入堆栈*/
scanf（"%d%ld%f",&ca1.tag,&ca1.carID,&ca1.time）;//输入车辆ca1的信息
/*对到达的车辆的处理*/
if（ca1.tag==1）
{
if（StackNotFull（S1））
{
printf（"该车停于停车场S1的第%d个停车位\n",S1.top）;
StackPush（&S1,ca1）;
}
else
{
printf（"该车停于便到的第%d个位置\n",Q.count）;
QueueAppend（&Q,ca1）;
}
}
else
{
StackDelete（&S1,ca1.carID,tt）;//调用StackDelete函数，将车辆ca1出停车场，并将其进入停车场是的时刻赋给t
if（t）
{
t=ca1.time-t;//如果该车辆是从停车场内开出的，将停留时间重新赋给t
if（QueueNotEmpty（Q））
{
QueueDelete（&Q,&ca2）;
ca2.time=ca1.time;
StackPush（&S1,ca2）;
}
/*如果此时变车道上有车辆的话记作ca2将其辆驶入停车场，
将其time改ca1离开时的time,即从ca1离开时对ca2开始计时*/
}
elset=0;//若该车辆不是从停车场开出的，显然其停留时间为
printf（"该车停留的时间t=%f,应收取的费用为money=%f\n",t,t*e）;
}
}
1.6测试情况
第一组数据的测试结果：
第二组数据的测试结果：
第三组数据的测试结果：
第四组数据的测试结果：
第二部分
求最短路径
2.1问题描述
在给定的图中，求出以任意顶点为源点，到其他顶点的最短路径。
2.2基本要求
1：
以邻接表作为存储结构。
2：
用Dijkstra算法求最短路径。
3：
按长度非递减次序打印输出最短路径长度以及所对应的路径。
2.3测试数据
2.3.1
无向图1
2.3.2
有向图2
2.4模块划分
1：
AdijMGraph.h文件中：
其中包括邻接表存储结构下的图的数据结构的定义，包括顶点结构体的定义，便结构体的定义，邻接表的定义。
初始化函数，在图中插入顶点函数，在图中插入边的函数。
2:
AdjMGraphCreate.h文件：
包括RowCal结构体的定义，以及图的建立函数voidCreatGraph（AdjlGraph*G,DataTypev[],intn,RowCold[],inte）
3：
Djikstra.h文件，最短路径的voidDijkstra（AdjlGraph*G,intv0,intdistance[],intpath[]）函数。
4：
work2.cpp文件对测试数据编写的测试主函数。
2.5数据结构
//边节点
typedefstructNode
{
intcost;//边权重
intdest;
structNode*next;
}Edge;
//图顶点结构
typedefstruct
{
DataTypedata;
intsource;
Edge*adj;
}AdjLHeight;
//邻接表结构下的图
typedefstruct
{
AdjLHeighta[MaxVert];
intnumofVerts;//顶点数
intnumofEdges;//边数
}AdjlGraph;
//快速创建图所定义的结构
typedefstruct
{
introw;//弧尾
intcol;//弧头
intcost;//边权重
}RowCol;
2.6源程序
/*****************************************AdjMGraph.h文件******************************************/
#include"malloc.h"
/*数据结构的定义*/
typedefstructNode
{
intcost;//theheavyofEdge
intdest;
structNode*next;
}Edge;/*边节点*/
typedefstruct
{
DataTypedata;
intsource;
Edge*adj;
}AdjLHeight;
typedefstruct
{
AdjLHeighta[MaxVert];//
intnumofVerts;//thenumberofvert
intnumofEdges;//thenumberofedge
}AdjlGraph;
//初始化图
voidAdjInitiate（AdjlGraph*G）
{
inti;
G->numofVerts=0;//顶点个数
G->numofEdges=0;//边个数
for（i=0;i{
G->a[i].source=i;
G->a[i].adj=NULL;
}
}
//插入顶点
voidInsertVertex（AdjlGraph*G,inti,DataTypevertex）
{
if（i>=0&&i{
G->a[i].data=vertex;
G->numofVerts++;
}
elseprintf（"顶点越界"）;
}
//插入边
voidInsertEdge（AdjlGraph*G,intv1,intv2,intcost）
{
Edge*p;
if（v1<0||v1>=G->numofVerts||v2<0||v2>=G->
升级会员 