数据结构-停车场管理-实习报告（5篇可选）

第一篇：数据结构-停车场管理-实习报告

实习报告

题目：停车场管理

一． 需求分析

1． 用栈来表示停车场，用队列来表示停车道。

2． 用户需输入车辆的必要信息，如车辆的到达或离开，汽车牌号以及到达或离去的时刻。停车场的容量及单位时间的停车费由编程序者自行设置，结构需输出车辆停车所需缴纳的费用。

3． 本程序要求对车辆的动态能够输出具体的信息内容，包括停车或离开的时间，位置，及所需缴纳的停车费。4． 测试数据为：

N=2，输入数据为：（’A’,1,5）,(‘A’,2.,10),(‘D’,1,15),(‘A’,3,20),(‘A’,4,25),(‘A’,5,30),(‘D’,2,35),(‘D’,4,40),(‘E’,0,0).其中：’A’表示到达，’D’表示离去，’E’表示输入结束。5.程序执行的命令为：

1.创建栈和队列。2.对车辆的行为进行相应的处理。3.输出车辆的信息。

二． 概要设计

1.设定栈的抽象数据类型定义：

ADT Stack{

数据对象：D={ai|ai属于Elem,i=1,2……,n, n>=0}

数据关系：R1={| ai-1,ai属于D，i=2,……，n}

基本操作：

InitStack(&S)

操作结果：构造一个空栈S.pop(&S,&e)

初始条件：栈S已存在。

操作结果：删除S的栈顶元素，并以e返回其值。

push(&S,&e)

初始条件：栈S已存在。

操作结果：在栈S的栈顶插入新的栈顶元素e。

EmptyStack(S)

初始条件：栈S已存在。

操作结果：若栈为空，则返回TRUE，否则，返回FALSE }ADT Stack;2.设定队列的抽象数据类型定义：

ADT Queue{

数据对象：D={ai| ai属于Elem, i=1,2,……，n, n>=0}

数据关系：R1={| ai-1,ai 属于D，i=2,……,n}

基本操作：

InitQueue(&Q)

操作结果：构造一个空队列Q.Append(&Q, e)

初始条件：队列Q已存在。

操作结果：插入元素e为Q的新的队尾元素。

Remove(&Q, &e)

初始条件：Q为非空队列。

操作结果：删除Q的对头元素，并用e返回其值。

EmptyQueue(Q)

初始条件：队列Q已存在。

操作结果：若队列为空，则返回TRUE，否则，返回FALSE

}ADT Queue 3.本程序主要包括三个模块

1.主程序模块；

int main(){

初始化；

do{

接受命令；

处理命令；

}while(命令！=退出)； } 2.处理车辆到达模块； 3.处理车辆离开模块；

各模块之间的调用关系如下：

处理车辆到达模块主程序模块处理车辆离开模块

三． 详细设计

设计程序如下： 1.栈的头文件

#ifndef _SQSTACK_H_ #define _SQSTACK_H_ struct Car { int plate, arrive_t;};class SqStack { public: int top;Car *base;int size;void InitStack(int m=100);bool EmptyStack()const;bool Push(Car &c);bool Pop(Car &c);};void SqStack::InitStack(int n){ base = new Car[n];top =-1;size = n;} bool SqStack::EmptyStack()const { if(top ==-1)

return true;else

return false;} bool SqStack::Push(Car &c){ if(top == sizec.arrive_t;if(timelong < 0){

cout << “the input is false,please do it again”<

packing.Push(c);

while(!temp.EmptyStack())

{

temp.Pop(c);

packing.Push(c);

}

return 0;} cout << “car ” << pla << “ was departed from packing lot” << endl;cout << “停留时间：” << timelong << endl;cout << “缴纳金额：” << timelong*price << endl;while(!temp.EmptyStack()){

temp.Pop(c);

packing.Push(c);}

if(!sevice_road.EmptyQueue())

{

sevice_road.Remove(c);

map[c.plate] = 0;

c.arrive_t = tim;

packing.Push(c);

cout << “car ” << c.plate << “ in packing lot” << endl;

} } return 0;} int main(){ cout << “请输入停车场规模” << endl;cout << “xxxxxxxxxx” << endl;int n;cin >> n;cout << “xxxxxxxxxx” << endl;SqStack packing, temp;LinkQueue sevice_road;packing.InitStack(n);temp.InitStack();sevice_road.InitQueue();cout << “请输入指令:A-arrive、D-depart、E-exit cout << ”xxxxxxxxxx“ << endl;char command;cin >> command;while(command!= 'E'){

if(command == 'A')

{

Arrive(packing, sevice_road);

cout << ”xxxxxxxxxx“ << endl;

}

if(command == 'D')

{

Depart(packing, temp, sevice_road);

cout << ”xxxxxxxxxx“ << endl;

}

cin >> command;} }

车牌号时间” << endl;

四． 调试与验收

1.本次作业是设计停车场的管理系统，就需要判断车牌号，及时间的输入的正确性，输入的数据有比较严格的要求，必须符合实际。因此对数据需要多次判断。2.处理车辆到达模块和处理车辆离开模块其空间复杂度为O(m*n);3.本程序循环用的很多，找车，排队，等等。

4.在验收时，老师提出一些当输入为不正常输入的时候的情况，而我没有考虑到，所以又做了一定的修改。

5.验收时，老师提到所加map破坏了程序整体结构的完好性，是有待改进的地方。

五

用户手册

1.按屏幕提示输入停车场规模和车辆信息； 2.回车显示车辆在停车场或停车道的信息； 3.输入E退出。

六． 测试结果

七 附录

源程序文件名清单： LinkQueue.cpp LinkQueue.h SqStack.cpp

SqStack.h 停车场管理.cpp

第二篇：数据结构 停车场管理 完整版 实习报告

实习报告

题目：停车场管理

一． 需求分析

1． 用栈来表示停车场，用队列来表示停车道。

2． 用户需输入车辆的必要信息，如车辆的到达或离开，汽车牌号以及到达或离去的时刻。停车场的容量及单位时间的停车费由编程序者自行设置，结构需输出车辆停车所需缴纳的费用。

3． 本程序要求对车辆的动态能够输出具体的信息内容，包括停车或离开的时间，位置，及所需缴纳的停车费。4． 测试数据为：

N=2，输入数据为：（’A’,1,5）,(‘A’,2.,10),(‘D’,1,15),(‘A’,3,20),(‘A’,4,25),(‘A’,5,30),(‘D’,2,35),(‘D’,4,40),(‘E’,0,0).其中：’A’表示到达，’D’表示离去，’E’表示输入结束。5.程序执行的命令为：

1.创建栈和队列。2.对车辆的行为进行相应的处理。3.输出车辆的信息。

二． 概要设计

1.设定栈的抽象数据类型定义：

ADT Stack{

数据对象：D={ai|ai属于Elem,i=1,2……,n, n>=0}

数据关系：R1={| ai-1,ai属于D，i=2,……，n}

基本操作：

initStack(&S)

操作结果：构造一个空栈S.pop(&S,&e)

初始条件：栈S已存在。

操作结果：删除S的栈顶元素，并以e返回其值。

push(&S,&e)

初始条件：栈S已存在。

操作结果：在栈S的栈顶插入新的栈顶元素e。

lengthstack(S)

初始条件：栈S已存在。

操作结果：返回S中的元素个数，即栈的长度。}ADT Stack;2.设定队列的抽象数据类型定义：

ADT Queue{

数据对象：D={ai| ai属于Elem, i=1,2,……，n, n>=0}

数据关系：R1={| ai-1,ai 属于D，i=2,……,n}

基本操作：

initqueue(&Q)

操作结果：构造一个空队列Q.enqueue(&Q, e)

初始条件：队列Q已存在。

操作结果：插入元素e为Q的新的队尾元素。

dequeue(&Q, &e)

初始条件：Q为非空队列。

操作结果：删除Q的对头元素，并用e返回其值。

Lengthqueue(Q)

初始条件：队列Q已存在。

操作结果：返回Q的元素个数，即队列的长度。}ADT Queue 3.本程序主要包括三个模块

1.主程序模块；

int main(){

初始化；

do{

接受命令；

处理命令；

}while(命令！=退出)； } 2.处理车辆到达模块； 3.处理车辆离开模块；

各模块之间的调用关系如下：

处理车辆到达模块主程序模块处理车辆离开模块

三． 详细设计

设计程序如下：

#include #define n 2

//将停车场的容量设为2； #define cost 10 //将单位时间的停车费设为10，车道里不收费；

#define OVERFLOW-2

#define ERROR 0 //分配栈的存储空间失败； using namespace std;

typedef struct Elem {//定义元素数据结构类型

int carnum;int time;}Elem;

typedef struct QNode {//队列

struct QNode *next;Elem Qelem;}QNode,*QueuePtr;

typedef struct { QueuePtr front;//队头指针

QueuePtr rear;//队尾指针 }LinkQueue;

void initqueue(LinkQueue &Q){//构造一个空队列

Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.front)exit(OVERFLOW);Q.front->next=Q.rear->next=NULL;}

void enqueue(LinkQueue &Q,int carnum,int time){//入队操作

QueuePtr p=(QueuePtr)malloc(sizeof(QNode));p->Qelem.carnum=carnum;p->Qelem.time=time;p->next=NULL;Q.rear->next=p;Q.rear=p;} int lengthqueue(LinkQueue Q){ int i=0;QueuePtr p;p=Q.front->next;while(p!=Q.rear){

i++;

p=p->next;} i++;return i;} void dequeue(LinkQueue &Q,Elem &e){//从对头离队操作，并返回其值 QueuePtr p=(QueuePtr)malloc(sizeof(QNode));if(Q.front==Q.rear)

cout<<“车道中没有车辆!”<

p=Q.front->next;

e=p->Qelem;

Q.front->next=p->next;

if(Q.rear==p)Q.rear=Q.front;

free(p);} } typedef struct { Elem *base;Elem *top;int stacksize;}Sqstack;void initStack(Sqstack &S){//创建一个空栈

S.base=(Elem*)malloc(n*sizeof(Elem));if(!S.base)exit(OVERFLOW);S.top=S.base;S.stacksize=n;} int push(Sqstack &S,Elem &e)//插入新的元素 { Elem *temp;if(S.top-S.base==S.stacksize)

return 1;else {

temp=S.top;

temp->carnum=e.carnum;

temp->time=e.time;

S.top++;

return 0;} } int lengthstack(Sqstack S){//当前栈的长度

return S.top-S.base;}

int pop(Sqstack &S,Elem &e){ //删除栈顶元素，并返回其值

if(S.top==S.base)return ERROR;e=*--S.top;return 1;} void carin(Sqstack &S,LinkQueue &Q,Elem car){ int k=0;//输入数据正确

QueuePtr r;Elem *temp;temp=S.base;while(temp!=S.top)/在栈中寻找是否有同一编号的车；

{

if(temp->carnum==car.carnum)

{

cout<<“该车号在停车场中已存在，请重新输入!”<

k=1;//找到了有同一编号的车

break;

}

temp++;} if(k==0&&Q.front!=Q.rear){//在栈中未找到，从队列中查找

r=Q.front->next;//队头

while(r&&r->Qelem.carnum!=car.carnum)

{r=r->next;}

if(r&&r->Qelem.carnum==car.carnum){cout<<“该车号在车道中已存在,请重新输入!”<

{

if(S.top-S.base!=S.stacksize)//说明栈未满，{

S.top->carnum=car.carnum;

S.top->time=car.time;

S.top++;

cout<<“请进入停车场”<

}

else

{

enqueue(Q,car.carnum,car.time);

cout<<“请便车道”<

} } }

void carleave(Sqstack &S,LinkQueue &Q,Elem car){ int ture=0;//在栈中没有找到与要离开的车

Elem e,em,*temp;

QueuePtr p,r;temp=S.base;if(ture==0){

while(temp!=S.top)//先在栈中寻找；

{

if(temp->carnum==car.carnum)

{

int temp_cost;

temp_cost=(car.time-temp->time)*cost;

ture=1;//在栈中找到

cout<<“您的停车时间为”<time<<“小时，请交纳费用!”<

break;

}

temp++;

}

if(ture==1)

//备用栈

{

Sqstack spear;

initStack(spear);

while(S.top!=temp+1)//先在栈中寻找；

{

pop(S,em);

push(spear,em);

}

pop(S,*temp);

if(spear.top!=spear.base)

{

while(spear.top!=spear.base)

{

pop(spear,em);

push(S,em);

} } } if(ture==1&&Q.front!=Q.rear)//栈中有车离开，将队列中的车进入栈中 { dequeue(Q,e);

//离队，并返回数据e S.top->carnum=e.carnum;S.top->time=car.time;S.top++;cout<

} } if(ture==0&&Q.front!=Q.rear)//栈中没找到要离开的车

{

p=Q.front;

r=Q.front->next;//队头

while(r&&r->Qelem.carnum!=car.carnum)

{

p=r;

r=r->next;

}

if(r&&r->Qelem.carnum==car.carnum)

ture=2;//在队列中找到要离开的车

if(r&&r->Qelem.carnum==car.carnum)

{

ture=2;

cout<<“便道”<Qelem.carnum<<“号车离开,不收取费用！”<

p->next=r->next;

free(r);

} }//直接从队列离开

if(ture==0)

cout<<“没有该辆车!”<

char c;

int j=0,temp_time,i=1;//i==0，判断临时记录时间的temp_time应该去该次的值，还是上次的值。j==0，表示第一次输入数据，不需要检测数据是否正确

LinkQueue Q;Sqstack S;Elem car;initqueue(Q);

initStack(S);

cout<<“请输入车辆信息（到达离开或退出标志A D E，车牌号，当前时间）”<

while(cin>>c>>car.carnum>>car.time)

{

if(j==1)

{

if(S.top==S.base)

cout<<“停车场中没有车!”<

else

{

if(car.time

{

cout<<“您输入的时间有误，请重新输入!”<

i=0;//temp_time还是记录上次的值

}

else

{

temp_time=car.time;

i=1;

}

}

if(i==1)//正确的数据

{

if(c=='A')//到达

carin(S,Q,car);

else if(c=='D')

{

if(S.top==S.base);

else

carleave(S,Q,car);

}

}

j=1;

}

if(j==0)//第一次输入数据不需要检测

{

if(c=='A')//到达

carin(S,Q,car);

else if(c=='D')

{

if(S.top==S.base)

cout<<“停车场中没有车!”<

else

carleave(S,Q,car);

}

j=1;

temp_time=car.time;

}

if(c=='E')

{

cout<<“输入结束！”<

break;

}

} return 0;}

四． 调试分析

1.本次作业是设计停车场的管理系统，就需要判断车牌号，及时间的输入的正确性，输入的数据有比较严格的要求，必须符合实际。因此对数据需要多次判断。2.处理车辆到达模块和处理车辆离开模块其空间复杂度为O(m*n);3.本程序循环用的很多，找车，排队，等等。4.主程序设计的有点乱。

五

用户手册

1.运行，按屏幕提示输入车辆信息；

2.回车显示车辆在停车场或停车道的信息； 3.输入E，则退出。

六． 测试结果

七 附录

#include

第三篇：数据结构课程设计-停车场管理

课 程 设 计 报 告

课程名称

数据 结构

题

目

停车场管理

学生姓名 班级/学号 191103

一、需求分析

设停车场是一个可停放n辆汽车的狭长通道，且只有一个大门可供

汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端），若停车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其他车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。试为停车场编制按上述要求进行管理的模拟程序。

【测试数据】

设n=2，输入数据为：（’A’,1,5），（’A’,2,10），（’D’,1,15），（’A’,3,20），（’A’,4,25），（’A’,5,30），（’D’,2,35），（’D’,4,40），（’E’,0,0）。其中：’A’表示到达；’D’表示离去；’E’表示输入结束。概要设计

以栈模拟停车场，以队列模拟车场外的便道。栈以顺序结构实现。队列以链表结构实现。每一组输入数据包括：汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去的时刻。

输出信息：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。

二、详细设计

三、程序设计

1.数据结构设计 /*栈，模拟停车场*/ typedef struct Car1 {

//车

int number;//汽车车号

int ar_time;//汽车到达时间 }CarNode;

typedef struct {

//停车场

CarNode *base;//停车场的堆栈底

CarNode *top;//停车场的堆栈顶

int stacksize;}Park;

/*队列，模拟便道*/ typedef struct Car2 {

//车

int number;//汽车车号

int ar_time;//汽车到达时间

struct Car2 *next;}*CarPtr;

typedef struct {

//便道

CarPtr front;//便道的队列的对头

CarPtr rear;//便道的队列的队尾

int length;}Shortcut;2.程序设计

主函数中包括3个子函数，A(arrive)，D（depart），E（end）

（1）输入车辆数据：A为到达，D为离去，E为结束程序。

（2）接着输入车辆的牌照信息

（3）若为到达的车辆，输入进场信息，若为离去的车辆，输入离场信息。（4）若车辆到达，可得到车辆的停放位置信息，若车辆离去，可得到车辆的停放时间（在便道上的停放时间除外），以及应该交纳的费用。

（5）本程序不断循环要求输入车辆信息，直到输入的车辆数据为E时，程序结束。

四、调试分析

a、一开始在调试程序时遇到了内存错误，经过DEBUG，找到了引起内存错误的原因：即在建立队头指针与队尾指针时没有对指针进行初始化(没有为指针动态分配空间)。问题得到解决。

b、本程序中：车辆到达,离去时的时间复杂度均为：O(n)。本程序空间复杂度为：O(n)

五、使用说明和测试结果

1.使用说明：用户按照屏幕所显示的提示来选择需要进行操作

2、测试结果：

测试结果满足题目要求，程序无错误。

六、心得体会

通过此实验，加深了我对数据结构这门课的理解，真正运用了知识。将理论与现实完美的联系在了一起。增强了动手能力，对今后的工作学习都有很大的帮助。单调的看书本没有太大的作用，只有去编程才能理解究竟学习的作用。同时，编程过程中遇到过各种各样的问题，与同学讨论，与老师交流。锻炼了我的协做能力与克服困难的能力。编程也极大的提高了我的学习积极性。

七、附录

#include #include #include #define SIZE 2//停车场位置数,共5个车位 typedef int Status;

/*栈，模拟停车场*/ typedef struct Car1 {

//车

int number;//汽车车号

int ar_time;//汽车到达时间 }CarNode;

typedef struct {

//停车场

CarNode *base;//停车场的堆栈底

CarNode *top;//停车场的堆栈顶

int stacksize;

}Park;

/*队列，模拟便道*/ typedef struct Car2 {

//车

int number;//汽车车号

int ar_time;//汽车到达时间

struct Car2 *next;}*CarPtr;

typedef struct {

//便道

CarPtr front;//便道的队列的对头

CarPtr rear;//便道的队列的队尾

int length;}Shortcut;/*初始化停车场*/ Status InitStack(Park &P){

P.base=(CarNode*)malloc(SIZE*sizeof(Car1));

if(!P.base)exit(-2);

P.top=P.base;

P.stacksize=0;

return 1;}

Status Push(Park &P,CarNode e){//车进入停车场

*P.top++=e;

++P.stacksize;

return 1;}

Status Pop(Park &P,CarNode &e){//车离开停车场

if(P.top==P.base)

printf(“停车场为空”);

else

{

e=*--P.top;

--P.stacksize;

}

return 1;} /*初始化便道*/ Status InitQueue(Shortcut &S){

S.front=S.rear=(CarPtr)malloc(sizeof(Car2));

if(!S.front||!S.rear)exit(-2);

S.front->next=NULL;

S.length=0;

return 1;}

Status EnQueue(Shortcut &S,int number,int ar_time){//车进入便道

CarPtr p;

p=(CarPtr)malloc(sizeof(Car2));

if(!p)exit(-2);

p->number=number;

p->ar_time=ar_time;

p->next=NULL;

S.rear->next=p;

S.rear=p;

++S.length;

return 1;}

Status DeQueue(Shortcut &S,CarPtr &w){//车离开便道

if(S.length == 0)

printf(“通道为空”);

else

{

w = S.front->next;

S.front->next=S.front->next->next;

--S.length;

}

return 1;}

Status Arrival(Park &P,Shortcut &S){//对进站车辆的处理

int number,ar_time;

printf(“请输入车牌号:”);

scanf(“%d”,&number);

printf(“进场的时刻:”);

scanf(“%d”,&ar_time);

if(P.stacksize

{

CarNode c;

c.number=number;

c.ar_time=ar_time;

Push(P,c);

printf(“请将车停在第%d号车道。n”,P.stacksize);

}

else

{

EnQueue(S,number,ar_time);

printf(“停车场已满，请暂时停在便道的第%d个位置。n”,S.length);

}

return 1;}

Status Leave(Park &P,Park &P1,Shortcut &S){//对离站车辆的处理

int number,le_time,flag=1,money,ar_time;

printf(“请输入车牌号:”);

scanf(“%d”,&number);

printf(“出场的时刻:”);

scanf(“%d”,&le_time);

CarNode e,m;

CarPtr w;

while(P.stacksize)

{

Pop(P,e);

if(e.number==number)

{

flag=0;

money=(le_time-e.ar_time)*2;

ar_time=e.ar_time;

break;

}

Push(P1,e);

}

while(P1.stacksize)

{

Pop(P1,e);

Push(P,e);

}

// 车从停车场中出

if(flag == 0)

{

if(S.length!=0)

{

DeQueue(S,w);

m.ar_time=le_time;

m.number=w->number;

Push(P,m);

free(w);

printf(“车牌号为%d的车已由便道进入停车场n”,m.number);

}

printf(“停车费为%d, 占用车位数为%dn”,money,P.stacksize);

}

else

{

printf(“停车场不存在牌号为%d的车n”, number);

}

return 1;} /*主函数*/ int main(){

int m=1;

char flag;//选项

Park P,Q;

Shortcut S;InitStack(P);InitStack(Q);InitQueue(S);

while(m)

{

printf(“n

停车场管理程序

n”);

printf(“A 汽车进车场

D 汽车出车场

E 退出程序n”);

printf(“请选择(A,D,E): ”);

scanf(“%c”,&flag);

switch(flag)

{

case 'A':

case 'a':

Arrival(P,S);break;//车进入停车场

case 'D':

case 'd':

Leave(P,Q,S);break;//车离开停车场

case 'E':

case 'e':

m=0;

break;

default:

printf(“Input error!n”);

break;

}

while(flag!= 'n')

scanf(“%c”,&flag);

} }

第四篇：数据结构课程设计报告_15_停车场管理

停车场管理系统

——数据结构课程设计程序设计书

小组成员：

彭路

20131344031 崔琦

20131344028 徐佳

20131344027 范福龙 20121344024 班级 ： 13软件工程1班 时间：2014.12.22

目录

一、程序设计目标

二、问题描述

三、需求分析

四、概要设计

五、详细设计

六、源程序清单

七、软件说明书

八、测试报告

九、课程设计总结

一、程序设计目标

本管理程序由c/c++语言完成，实现了对停车场收费问题的处理。本程序保证了程序的健壮性和操作性，在阅读过使用说明书之后可以轻松使用。本管理系统假设车辆在停车场时一直有人在驾驶，或者说停车场的每块停车位均可智能移动。并假设车辆进出场耗时不计，且时间均为整数类型。最后自动或者人工完成收费。

二、问题描述

设停车场内只有一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后开入的车辆必须先退出车场为它让路，待该辆车开出大门外，其它车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。试为停车场编制按上述要求进行管理的模拟程序。

三、需求分析

根据问题描述，可把本停车场抽象成一个栈存储类型s1，需要输入最大停车容量n。每当输入’A’时即为有车辆申请进入停车场操作，此时需要判断停车场是否有空位，如果有空位，那么这辆车可以进入停车场，即为执行一次压栈操作（push），并记录进入停车场的时间t1，并输出位置p1；如果停车场没有空位，那么这辆车在门外便道等候，并输出位置p2。根据问题描述，可以把此门外便道抽象成一个队列存储类型q，而每有一辆车进入门外便道，即相当于进行一次插入队列操作（push）。每当输入’D’时即为有车辆申请离开停车场操作，此时需要判断该车辆在停车场的位置。如果该车位于停车场最外侧即相当于栈顶，那么该车可以直接批准离开并根据输入的离开时间t2计算出停车时间t2-t1，根据该车本次停车时间完成收费后即可成功驶出停车场，即相当于成功弹出栈顶元素（pop）；如果该车没有位于停车场最外侧，事实上，这也是大多数的情况，那么需要将该车外侧的车依次（即为挡路的车）移动进一个临时停车场，根据问题描述，可以将该临时停车场抽象成另一个栈存储类型s2，那么此次移动操作相当于将栈中某元素以上的元素依次压入另一个栈（push）。当申请离开的车驶出停车场后，在临时停车场的车辆依次进入停车场，此操作相当于将栈s2内元素依次弹出栈（pop）并压入栈s1（push）。此时判断门外便道上有无等待进入停车场的车辆，如果有的话，门外便道上第一辆车可以进入停车场，并记录进入时间t1，此次操作相当于取出队列q的队首元素并将其压入栈s1中。而输入’E’时，即退出系统。至此，所有分析结束。

四、概要设计

根据需求分析，解决此问题需要构建一个Cars类型的结构体，构建一个CarNode类型的节点结构体以构建SQueue类型的队列结构体，并需要构建一个SQstack类型的栈结构体。接下来，分别定义队列和栈的各项基本操作函数。最后，完成菜单函数以实现各项操作。

五、详细设计

本程序定义了三个头文件，manager_cars.h、manager_stack.h、manager_queue.h。分别实现了Cars类型的结构体、SQueue类型的队列结构体、SQstack类型的栈结构体以及队列的相关操作函数和栈的相关操作函数。具体如下：

1、manager_cars.h

sq->lastCar=car;sq->firstCar->nextCar=NULL;sq->length=0;} //进入队列操作

void enterSQueue(SQueue *sq,int num,int t){ CarNode *car=(CarNode *)malloc(sizeof(CarNode));car->headCar.condition='D';car->headCar.number=num;car->headCar.time=t;car->headCar.position=2;

car->nextCar=NULL;sq->lastCar->nextCar=car;sq->lastCar=car;sq->length++;} //出队列操作

void exceedSQueue(SQueue *sq){ if(sq->firstCar==sq->lastCar)

return;CarNode *car=(CarNode *)malloc(sizeof(CarNode));car=sq->firstCar->nextCar;sq->firstCar->nextCar=car->nextCar;sq->length--;if(sq->lastCar==car)

sq->lastCar=sq->firstCar;free(car);

}

//检测队列存在

int SQueueEmpty(SQueue sq){ if(sq.firstCar==sq.lastCar)

return 1;else

return 0;} //获取队首元素

void getSQueue(SQueue sq,Cars *e){ if(sq.firstCar==sq.lastCar)

return;*e=sq.firstCar->nextCar->headCar;S.base;}

extern int GetTop(SQstack S,Cars *e)//若栈不为空，则用e返回S的栈顶元素，并返回OK;否则返回ERROR { if(S.top == S.base)return 0;

*e = *(S.top-1);

return 1;

}

extern int Push(SQstack*S,Cars e)//插入元素e为新的栈顶元素

{ if(S->top

cout<<“请正确输入Y或N:”<

scanf(“%c”,&flag);

getchar();} while(flag=='Y'){

flag='C';

Cars car;

SQstack park;//定义栈并初始化

InitStack(&park);

SQueue street;//定义队列并初始化

setSQueue(&street);

cout<<“请输入本停车场最多可提供的车位数:”;

scanf(“%d”,&maxNum);

getchar();

cout<<“请输入每小时停车费：”;

cin>>Pprice;

cout<

cout<<“请输入到达(A)/离开(D)信息，车牌号，时间（格式为A 1 5）:”;

cin>>car.condition>>car.number>>car.time;

//scanf(“%c %d %d”,&car.condition,&car.number,&car.time);

//getchar();

while(car.condition!='E'&&car.number!=0&&car.time!=0)

{

switch(car.condition)

{

case 'A':

{

enterPark(car,park,street);

break;

}

case 'D':

{

int lasttime;

lasttime=outOfPark(car,park,street,car.number,car.time);

cout<

cout<<“此车在停车场停留了”<break;

}

default :cout<<“请输入正确的格式！”<

}

cin>>car.condition>>car.number>>car.time;

//scanf(“%c %d %d”,&car.condition,&car.number,&car.time);

Cars headCar;struct CarNode *nextCar;}CarNode;

typedef struct { CarNode *firstCar;CarNode *lastCar;

int length;}SQueue;//建队列链表

void setSQueue(SQueue *sq){ CarNode *car=(CarNode *)malloc(sizeof(CarNode));sq->firstCar=car;sq->lastCar=car;sq->firstCar->nextCar=NULL;sq->length=0;} //进入队列操作

void enterSQueue(SQueue *sq,int num,int t){ CarNode *car=(CarNode *)malloc(sizeof(CarNode));car->headCar.condition='D';car->headCar.number=num;car->headCar.time=t;car->headCar.position=2;

car->nextCar=NULL;sq->lastCar->nextCar=car;sq->lastCar=car;sq->length++;} //出队列操作

void exceedSQueue(SQueue *sq){ if(sq->firstCar==sq->lastCar)

return;CarNode *car=(CarNode *)malloc(sizeof(CarNode));car=sq->firstCar->nextCar;sq->firstCar->nextCar=car->nextCar;sq->length--;if(sq->lastCar==car)

sq->lastCar=sq->firstCar;free(car);

}

//检测队列存在

int SQueueEmpty(SQueue sq){ if(sq.firstCar==sq.lastCar)

return 1;else

return 0;} //队首元素

void getSQueue(SQueue sq,Cars *e){ if(sq.firstCar==sq.lastCar)

return;*e=sq.firstCar->nextCar->headCar;}

//队列长度

int SQueueLength(SQueue sq){ int len=0;if(sq.firstCar!=sq.lastCar)len=sq.length;return len;}

#endif

manager_stack.h #include #include #include“manager_cars.h”

#ifndef manager_stack_h #define manager_stack_h

#define STACK_INIT_SIZE 100 //栈的存储空间初始分配量 #define STACKINCREMENT 10 //栈的存储空间分配增量

typedef struct SQstack

//栈的结构体

{ Cars * base;Cars * top;int stacksize;S.base;}

extern int GetTop(SQstack S,Cars *e)//若栈不为空，则用e返回S的栈顶元素，并返回OK;否则返回ERROR { if(S.top == S.base)return 0;

*e = *(S.top-1);

return 1;

}

extern int Push(SQstack*S,Cars e)//插入元素e为新的栈顶元素

{ if(S->top-S->base >= S->stacksize)

{

S->base =(Cars *)realloc(S->base,(S->stacksize + STACKINCREMENT)*sizeof(Cars));

if(!S->base)return 0;

S->top = S->base + S->stacksize;

S->stacksize += STACKINCREMENT;

}

*S->top++ = e;

return 1;

}

extern int Pop(SQstack *S,Cars *e)//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK,否则返回ERROR { if(S->top == S->base)return 0;

*e = *--S->top;

return 1;

}

#endif

七、软件说明书

1、打开系统，输入Y进入管理系统。

2、接下来按提示输入停车场的可供使用的车位数。

3、按提示输入该停车场每小时收费标准。

4、按提示输入到达后者离开信息，例如A 1 5，D 1 10。

5、输入E 0 0并输入N，退出系统。

八、测试报告

1、如图，当打开系统时出现此界面，输入Y为进入系统，输入N为退出系统。

2、如图，如果输入错误会提示出错，并重新输入。

3、如图，输入Y后，按提示依次输入停车场可提供的最大车位数和每小时的停车费。

4、如图，输入A 1 5后，提示进入停车场的信息。

5、如图，输入A 2 10，A 3 15后，依次显示提示信息。

6、如图，输入D 1 20后，分别显示便道进入停车场的3号车和1号车的收费情况。

7、如图，输入E 0 0，再按提示输入N，即可退出系统。

九、课程设计总结

通过团队对该问题分析，互相补充了观点，增强了对该题目正确认识。队员们进行了缜密的需求分析，并分工完成各文件和函数的编写。队员们纷纷表示，这绝对是一个以前不能想象到的任务。通过对该系统的编写、实现，着实增强了队员们的团队意识以及对数据结构的进一步的理解。当程序成功运行后，队员们都非常兴奋，虽然本系统仍有瑕疵，但是可以说这是队员们的心血。

0

第五篇：数据结构实习报告

数据结构课程设计的实习报告怎么写呀，请求做过课设的同学发一篇范文过来谢谢-_-规范实习报告的开头应给出题目、班级、姓名、学号和完成日期，并包括以下七个内容：

1、需求分析以无歧义的陈述说明程序设计的任务，强调的是程序要做什么?明确规定：(1)输入的形式和输入值的范围；(2)输出的形式；(3)程序所能达到的功能；(4)测试数据：包括正确地输入及其输出结果和含有错误的输入及其输出结果，数据结构实习报告。

2、概要设计说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。

3、详细设计实现概要设计中定义的所有数据类型，对每个操作只需要写出伪码算法；对主程序和其他模块也都需要写出伪码算法(伪码算法达到的详细程度建议为：按照伪码算法可以在计算机键盘直接输入高级程序设计语言程序)；画出函数的调用关系图。

4、调试分析内容包括：(1)调试过程中遇到的问题是如何解决的以及对设计与实现的回顾讨论和分析；(2)算法的时空分析(包括基本操作和其他算法的时间复杂度和空间复杂度的分析)和改进思想；(3)经验和体会等，实习报告《数据结构实习报告》。

5、用户使用说明说明如何使用你编写的程序，详细列出每一步操作步骤。

6、测试结果列出你的测试结果，包括输入和输出。这里的测试数据应该完整和严格，最好多于需求分析中所列。

7、附录题目：约瑟夫-实习报告尺寸：约瑟夫-实习报告.doc目录：

一、需求分析

二、概要设计

三、程序具体设计及函数调用关系

四、调试分析

五、测试结果原文：实习报告题目：约瑟夫(Joseph)问题的一种描述是：编号为1，2，.，n的n个人按顺时针方向围坐一圈，每人持有一个密码(正整数)。一开始任选一个整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个开始重新从1报数，如此下去，直至年有人全部出列为止。试设计一个程序求出出列顺序。班级：姓名：学号：完成日期：

一、需求分析1.本演示程序中，利用单向循环链表存储结构存储约瑟夫环数据(即n个人的编号和密码)。2.演示程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中需要输入的数据，运算结果显示在其后。3.程序执行的命令包括：1)构造单向循环链表；2)4.测试数据m的初值为20；n=7，7个人的密码依次为：3，1，7，2，4，8，4，首先m值为6(正确的出列顺序为6，1，4，7，2，1，3，5)。

二、概要设计1.单向循环链表的抽象数据类型定义为：ADT List{数据对象：D={ai|ai∈正整数，I=1，2，.，n,n≥0}数据关系：R1={ai-1，ai|，ai-1，ai∈D,I=1，2，.，n}基本操作：Init List(&L)操作结果：构造一个空的线性表L。List Insert(&L,i,e)初始条件：线性表L已存在，1≤i≤List Length(L)+1.操作结果：在L中第i个位置之前插入新的数据无素e，L长度加1。List Delete(&L,i,&e)初始条件：线性表L存在非空，1≤i≤List Length(L).操作结果：删除L的第i个元素，并用e返回其值，L长度减1。2.程序包含四个模块：1)主程序模块：void main(){.