数据结构实验报告模拟停车场管理(含代码)
停车场模拟管理程序设计报告(附源代码)
停车场模拟管理程序的设计与实现一、简介1．设计目的：理解线性表的逻辑结构和存储结构，进一步提高使用理论知识指导解决实际问题的能力。
2．问题的描述：设停车场只有一个可停放几辆汽车的狭长通道，只有一个大门可供汽车进出。
汽车在停车场内按车辆到达的先后顺序依次排列，若车场内已停满几辆汽车，则后来的汽车只能在门外的便道上等候，一旦停车场内有车辆开走，则排在便道上的第一辆汽车即可进入；当停车场内某辆汽车要开走时，由于停车场是狭长的通道，在它之后开入的车辆必须先推出车场为他让路，待车辆开出大门，为他让路的车辆再按原次序进入车场。
试设计这样一个停车场模拟管理程序。
二、数据结构的设计：（1）为了便于区分每辆汽车并了解每辆车当前所处的位置，需要记录汽车的牌照号码和汽车当前的状态。
（2）为了便于停车场的管理，要为每个车位分配一个固定的编号。
（3）当停车场的停车位上都已停满了汽车，又有新的汽车到来时要把它调度到便道上，便道上的车辆要按照进入便道的先后顺序顺次序放在便道上，为便道上的每个位置分配一个固定的编号。
当有车从停车位上离开后，便道上的第一辆汽车就立即进入停车位上的某个车位。
（4）当某辆车离开停车场的时候，比他后进停车位的车要为他让路，而且当他开走之后让路的车还要按照原来的停放次序再次进入停车位的某个车位上，为完成这项功能，定义一个结构体。
三、功能（函数）设计：本程序从总体上分为四个功能模块，分别为：（1）程序功能介绍和操作提示模块（2）汽车进入停车位的管理模块（3）汽车离开停车位的管理模块（4）查看停车场状态的查询模块四、界面设计：本程序界面本着易于操作简单整洁而不失美观的理念，采用数字对应功能选项，结合详细的操作提示，使得操作方便快捷，界面清晰明朗。
五、程序设计： 1车辆进入停车场模块：Arrive 函数Enter->top<MAX?执行语句实现进入便道执行语句实现进入车站Y N·Arrive 函数：有车进入停车厂；·Enter->top<MAX ：对栈进行判满，Y 表示栈满，进入便道；N 表示栈不满，进入车站；2车辆离开停车场模块:·Leave函数：有车的话就要离开车位。
数据结构-停车场管理程序代码
源程序代码：#include <stdio.h>#include <stdlib.h>#include <iostream.h>#include <time.h>#define MaxSize 5#define fee 2#define L 10000#define M 20000typedef int ElemType;ElemType tmpnum=0;ElemType tmptime=0;typedef struct {ElemType car_num[MaxSize];ElemType car_time[MaxSize];int top;}STACK;typedef struct qnode {ElemType car_num;ElemType car_time;struct qnode *next;}QTYPT;typedef struct qptr {QTYPT *front;QTYPT *rear;}SQUEUE;SQUEUE LQ;void InitStack(STACK *S){S->top = -1;}int Full(STACK *S){if(S->top==MaxSize-1){printf("\n Stack is full! Push");return 0;}return 1;}int Push(STACK *S,ElemType num,ElemType time){ if(S->top==MaxSize-1){printf("\n Stack is full! Push");return 0;}S->top++;S->car_num[S->top]=num;S->car_time[S->top]=time;return 1;}int Empty(STACK *S){return (S->top==-1 ? 1:0);}int Pop(STACK *S,ElemType *num,ElemType *time){if(Empty(S)){puts("Stack is free Pop");return 0;}*num=S->car_num[S->top];*time=S->car_time[S->top];S->top--;return 1;}int GetTop(STACK *S,ElemType *num,ElemType *time){ if(Empty(S)){puts("Stack is free Gettop");}*num=S->car_num[S->top];*time=S->car_time[S->top];return 1;}void InitQueue(SQUEUE *LQ){QTYPT *p=NULL;p=(QTYPT *)malloc(sizeof(QTYPT));p->next=NULL;LQ->front=LQ->rear=p;}int EnQueue(SQUEUE *LQ,ElemType num,ElemType time){ QTYPT *s;s=(QTYPT *)malloc(sizeof(QTYPT));s->car_num=num;s->car_time=time;s->next=LQ->rear->next;LQ->rear->next=s;LQ->rear=s;return 1;}int CountQueue(SQUEUE *LQ){int i=1;QTYPT *mfront=NULL;QTYPT *mrear=NULL;mfront=LQ->front;mrear=LQ->rear;while(!(LQ->front==LQ->rear)){i++;LQ->front=LQ->front->next;}LQ->front=mfront;return i;}int Empty_Q(SQUEUE *LQ){return (LQ->front==LQ->rear?1:0);}int OutQueue(SQUEUE *LQ,ElemType *num,ElemType *time){ QTYPT *p;if(Empty_Q(LQ)){puts("Quenue is free OutQuenue");return 0;}p=LQ->front->next;*num=p->car_num;*time=p->car_time;LQ->front->next=p->next;if(LQ->front->next==NULL)LQ->rear=LQ->front;free(p);return 1;}int GetHead(SQUEUE *LQ,ElemType *num,ElemType *time){ if(Empty_Q(LQ)){puts("Quenue is free GetHead");return 0;}*num=LQ->front->next->car_num;*time=LQ->front->next->car_time;return 1;}void sleep(int time){clock_t goal;goal=time*(CLOCKS_PER_SEC)+clock();while(goal > clock()){;}}int chackinput(STACK *S,int pnum){int i=0;int num;num = pnum;i=S->top;for(;!(i==-1);i--)if(S->car_num[i]==num)return 1;return 0;}int chacktime(STACK *S,int ptime){return S->car_time[S->top] <= ptime ? 1 : 0;}int displaystats(STACK *S,int pinput){void displayhead(void);int i = 0;i = S->top;switch(pinput){case 10000:{if(!Empty(S))for(;!(i==-1);i--)printf("<===%d时%d号车停与%d车位===>\n",S->car_time[i],S->car_time[i],i+1);elsecout<<"停车场为空";printf("还有车%d个位\n",MaxSize-S->top-1);break;}case 20000:{displayhead();break;}default:{return 1;}}return 0;}void displayhead(void){cout<<'\n'<<"<===============CT停车场管理系统===================>"<<endl;cout<<"<==操作说明: ******* ==>"<<endl;cout<<"<==A：停车命令 ******* ==>"<<endl;cout<<"<==D：出车命令 *** ==>"<<endl;cout<<"<==E：退出程序 *** ==>"<<endl;cout<<"<==L: 显示停车场内状况 "<<endl;cout<<"<==============================================>"<<endl;}void displayChange(STACK *S,ElemType pnum,int ptime){printf(" (单价 %d元/小时 )\n",fee);printf("<======================电子收据===================>\n");printf("<==停车时间:--------------------------%d小时==>\n",ptime-tmptime);printf("<==车牌号码:--------------------------%d==>\n",tmpnum);printf("<==应收费用:--------------------------%d 元==>\n",(ptime-tmptime)*fee);printf("<====================谢谢=欢迎下次再来=============>\n");printf("正在打印收据请稍等\n");for(int count=1; count < 1;count++){printf("=");fflush(stdout);sleep(1);}printf(">\n");sleep(1);}void wait(char *string){printf("%s\n",string);for(int count=1; count < 1;count++){printf("-");fflush(stdout);sleep(1);}printf(">\n");}int outparkstation(STACK *S1,STACK *TS,ElemType pnum){int t_num=0;int t_time=0;while(1){Pop(S1,&t_num,&t_time);if(t_num == pnum){tmpnum=t_num;tmptime=t_time;while(!Empty(TS)){Pop(TS,&t_num,&t_time);Push(S1,t_num,t_time);}return 1;}Push(TS,t_num,t_time);}return 0;}int inparkstation(STACK *S){int parknum;int parktime;printf("还有车%d个位\n",MaxSize-S->top-1);printf("请输入车牌号码:");cin>>parknum;while(chackinput(S,parknum)){ printf("车牌号码重复，请输入%d1或者其他",parknum);cin>>parknum;}printf("请输入停车时间:");cin>>parktime;printf("%d号车于%d时停靠在%d位\n",parknum,parktime,S->top+2);Push(S,parknum,parktime);return 1;}int inbiandao(SQUEUE *SQ,STACK *S){int parknum ;printf("对不起,停车场已满，请您到便道等待.您将第");printf("%d进入停车场\n",CountQueue(SQ));printf("请输入车牌号码:");cin>>parknum;while(chackinput(S,parknum)) { printf("车牌号码重复，请输入%d1或者其他",parknum);cin>>parknum;} EnQueue(SQ,parknum,0);return 1;}int OutParkingStation(SQUEUE *biandao,STACK *car,STACK *tmp){int parknum = 0;int parktime = 0;int buf=0;if(!Empty(car)){displaystats(car,10000);printf("请输入您要调出的车牌号码:");cin>>parknum;while(!chackinput(car,parknum)) { printf("没有您要的%d的车牌号码,请输入正确的车牌号码：",parknum);cin>>parknum;} outparkstation(car,tmp,parknum); printf("%d时%d号车进入停车场\n",tmptime,tmpnum);printf("请输入现在的时间:");cin>>parktime;while(!chacktime(car,parktime)) { cout<<"输入时间小于停车时间，请重新输入:";cin>>parktime; }displayChange(car,parknum,parktime); if(biandao->front==biandao->rear) { }else{ printf("%d号车位空开\n",car->top+2);printf("%d时便道上的%d号汽车驶入%d号车位",parktime,biandao->front->next->car_num,car->top+2);OutQueue(biandao,&parknum,&buf); Push(car,parknum,parktime); }return 2;}printf("停车场为空\n"); return 1; };int main(int argc,char* agv[]){char chance='A';STACK car;InitStack(&car);STACK tmp;InitStack(&tmp);SQUEUE biandao;InitQueue(&biandao);loop:while(1){displayhead();cout<<"=>:";cin>>chance;switch(chance) {case 'A':{wait("正在查询车位，请稍等：");if(Full(&car))inparkstation(&car);elseinbiandao(&biandao,&car);break;}case 'D':{OutParkingStation(&biandao,&car,&tmp);break;}case 'L':{displaystats(&car,10000);break;}case 'M':{displaystats(&car,20000);break;}case 'E':{wait("正在保存数据程序即将退出\n命令执行中:"); exit(0);}default:{cout<<"输入错误"<<endl;goto loop;}}}system("PAUSE");return 0;}。
数据结构停车场管理实验报告
数据结构停车场管理实验报告一、实验目的本次实验旨在通过设计和实现一个停车场管理系统，深入理解和应用数据结构中的栈和队列等知识，提高解决实际问题的能力。
二、实验环境编程语言：C+＋开发工具：Visual Studio三、实验原理1、停车场采用栈结构来存储停放的车辆信息。
栈具有先进后出的特点，符合车辆先进入停车场后离开的逻辑。
2、停车场外的便道采用队列结构来存储等待进入停车场的车辆。
队列具有先进先出的特点，符合车辆按到达顺序进入停车场的需求。
四、实验内容1、设计数据结构定义栈和队列的数据结构，包括存储车辆信息的结构体。
实现栈和队列的基本操作，如入栈、出栈、入队、出队等。
2、功能实现车辆进入停车场：当有车辆进入停车场时，将车辆信息压入栈中。
车辆离开停车场：当有车辆离开停车场时，从栈中弹出相应车辆，并计算停车费用。
显示停车场状态：实时显示停车场内车辆的信息。
处理便道上的车辆：当停车场有空位时，将便道上的车辆依次入停车场。
3、界面设计设计简单的命令行交互界面，方便用户输入操作指令。
五、实验步骤1、定义数据结构｀｀｀cppstruct Car ｛int carNumber;int arrivalTime;int departureTime;｝；class Stack ｛private:Car stackArray;int top;int capacity;public:Stack(int size) ｛capacity ＝ size;stackArray ＝ new Carcapacity; top ＝－1;｝～Stack(）｛delete stackArray;｝bool isFull(）｛return top ＝＝ capacity 1;｝bool isEmpty(）｛return top ＝＝－1;｝void push(Car car) ｛if （！isFull(））｛stackArray+＋top ＝ car;｝ else ｛std:：cout ＜＜＂停车场已满，无法进入！＂＜＜ std:：endl;｝｝Car pop(）｛if （！isEmpty(））｛return stackArraytop;｝ else ｛std:：cout ＜＜＂停车场为空，无法离开！＂＜＜ std:：endl; return ｛－1, －1, －1}；｝｝Car peek(）｛if （！isEmpty(））｛return stackArraytop;｝ else ｛std:：cout ＜＜＂停车场为空！＂＜＜ std:：endl; return ｛－1, －1, －1}；｝｝｝；class Queue ｛private:Car queueArray;int front;int rear;int capacity;public:Queue(int size) ｛capacity ＝ size;queueArray ＝ new Carcapacity;front ＝ rear ＝－1;｝～Queue(）｛delete queueArray;｝bool isFull(）｛return （rear ＋ 1) ％ capacity ＝＝ front;｝bool isEmpty(）｛return front ＝＝－1;｝void enqueue(Car car) ｛if （！isFull(））｛if （isEmpty(））｛front ＝ 0;｝rear ＝（rear ＋ 1) ％ capacity; queueArrayrear ＝ car;｝ else ｛std:：cout ＜＜＂便道已满，无法等待！＂＜＜ std:：endl;｝｝Car dequeue(）｛if （！isEmpty(））｛Car car ＝ queueArrayfront;if （front ＝＝ rear) ｛front ＝ rear ＝－1;｝ else ｛front ＝（front ＋ 1) ％ capacity;｝return car;｝ else ｛std:：cout ＜＜＂便道为空！＂＜＜ std:：endl;return ｛－1, －1, －1}；｝｝Car frontElement(）｛if （！isEmpty(））｛return queueArrayfront;｝ else ｛std:：cout ＜＜＂便道为空！＂＜＜ std:：endl;return ｛－1, －1, －1}；｝｝｝；｀｀｀2、主函数实现｀｀｀cppint main(）｛int parkingLotCapacity ＝ 10; ／／假设停车场容量为 10 Stack parkingLot(parkingLotCapacity)；Queue waitingQueue(parkingLotCapacity)；int choice;while （true) ｛std:：cout ＜＜＂1、车辆进入停车场" ＜＜ std:：endl;std:：cout ＜＜＂2、车辆离开停车场" ＜＜ std:：endl;std:：cout ＜＜＂3、显示停车场状态" ＜＜ std:：endl;std:：cout ＜＜＂4、退出" ＜＜ std:：endl;std:：cout ＜＜＂请选择操作：＂；std:：cin ＞＞ choice;switch （choice) ｛case 1: ｛int carNumber;std:：cout ＜＜＂请输入车辆号码：＂；std:：cin ＞＞ carNumber;Car car ＝｛carNumber, time(NULL)，－1}；if （！parkingLotisFull(））｛parkingLotpush(car)；std:：cout ＜＜＂车辆＂＜＜ carNumber ＜＜＂进入停车场" ＜＜std:：endl;｝ else ｛waitingQueueenqueue(car)；std:：cout ＜＜＂停车场已满，车辆＂＜＜ carNumber ＜＜＂在便道等待" ＜＜ std:：endl;｝break;｝case 2: ｛int carNumber;std:：cout ＜＜＂请输入要离开的车辆号码：＂；std:：cin ＞＞ carNumber;Car car;bool found ＝ false;for （int i ＝ parkingLottop; i ＞＝ 0; i) ｛if （parkingLotstackArrayicarNumber ＝＝ carNumber) ｛car ＝ parkingLotpop(）；cardepartureTime ＝ time(NULL)；found ＝ true;break;｝｝if （found) ｛int parkingTime ＝ difftime(cardepartureTime, cararrivalTime)；double parkingFee ＝ parkingTime 2; ／／假设每单位时间停车费为2 元std:：cout ＜＜＂车辆＂＜＜ carNumber ＜＜＂离开停车场，停车时间：＂＜＜ parkingTime ＜＜＂秒，停车费用：＂＜＜parkingFee ＜＜＂元" ＜＜ std:：endl;if （！waitingQueueisEmpty(））｛Car waitingCar ＝ waitingQueuedequeue(）；parkingLotpush(waitingCar)；std:：cout ＜＜＂便道上的车辆＂＜＜ waitingCarcarNumber ＜＜＂进入停车场" ＜＜ std:：endl;｝｝ else ｛std:：cout ＜＜＂未找到要离开的车辆" ＜＜ std:：endl;｝break;｝case 3: ｛std:：cout ＜＜＂停车场内车辆：＂＜＜ std:：endl;for （int i ＝ parkingLottop; i ＞＝ 0; i) ｛std:：cout ＜＜ parkingLotstackArrayicarNumber ＜＜＂＂；｝std:：cout ＜＜ std:：endl;std:：cout ＜＜＂便道上等待的车辆：＂＜＜ std:：endl;if （！waitingQueueisEmpty(））｛for （int i ＝ waitingQueuefront; i!＝ waitingQueuerear; i ＝（i ＋ 1) ％waitingQueuecapacity) ｛std:：cout ＜＜ waitingQueuequeueArrayicarNumber ＜＜＂＂；｝std:：cout ＜＜ waitingQueuequeueArraywaitingQueuerearcarNumber＜＜ std:：endl;｝ else ｛std:：cout ＜＜＂无" ＜＜ std:：endl;｝break;｝case 4:return 0;default:std:：cout ＜＜＂无效的选择，请重新输入" ＜＜ std:：endl;｝｝return 0;｝｀｀｀六、实验结果1、车辆正常进入停车场，并在停车场已满时在便道等待。
数据结构--停车场管理-完整版-实习报告
实习报告题目：停车场管理一．需求分析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>| 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>| ai-1,ai 属于D，i=2,……,n}基本操作：initqueue(&Q)操作结果：构造一个空队列Q.enqueue(&Q, e)初始条件：队列Q已存在。
数据结构停车场管理实验报告
停车场管理实验报告姓名：学号：学院：继续教育学院班级：计算机科学与技术一．实验目的和要求熟练栈和队列的结构特性，掌握在实际问题背景下的应用二．实验主要内容以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。
每一组输入数据包括三个数据项：汽车“达到”或“离去”信息、汽车牌照号码以及达到或离去的时刻。
对每一组输入数据进行操作后的输出信息为：若是车辆达到、则输出汽车在停车场内或便道上停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。
栈以顺序结构实现，队列以链表结构实现。
三．实验仪器和环境PC机Windows xp Visual c++ c语言四．实验原理1.概要设计（1）抽象数据类型定义ADT Stack{数据对象:D={ai|ai ∈ElemSet, i=1,2,…n;n>0}数据关系:R1={<ai-1,ai>|ai-1,ai ∈D,i=2,…n}基本操作:InitStack(&S)操作结果：构造一个空栈S。
Push(&S,e)初始条件：栈S已存在。
操作结果：插入e为新的栈顶元素Pop(&S,&e)初始条件：栈S已存在。
操作结果：删除S的栈顶元素,并且用e返回。
}ADT StackADT Queue {数据对象:D={ai|ai ∈ElemSet, i=1,2,…n; n>0}数据关系:R1={<ai-1,ai>|ai-1,ai ∈D, i=2,…n}其中:a1为队头, an为队尾基本操作:InitQueue(&Q);操作结果：构造一个空队列QEnQueue(&Q,&e);初始条件：对列Q已存在。
操作结果：插入元素e为Q的新队尾元素。
DeQueue(&Q,&e);初始条件：对列Q已存在。
操作结果：删除Q的队头元素, 并用e返回。
数据结构课程设计 停车场模拟管理系统报告(含源码)
数据结构课程设计停车场模拟管理系统报告(含源码)《数据结构课程设计》报告专业：软件工程班级： T1123-03学号：姓名： XXX课设题目：停车场模拟管理系统指导教师：马春江成绩：2013-07-03目录一、设计题目 (1)二、设计目的 (1)三、总体设计 (1)（一）问题描述 (1)（二）设计要求 (2)（三）数据结构 (2)四、详细设计 (2)（一）分析与实现 (2)（二）系统模块设计 (3)（三）界面设计 (4)五、设计结果与分析 (6)六、总结（收获和不足） (6)（一）课设的不足 (6)（二）课设的收获 (7)附录程序源码 (7)参考文献： (19)指导教师意见 (20)一、设计题目停车场模拟管理系统。
二、设计目的利用所学的知识，模拟设计一个停车场管理系统。
通过程序设计，了解停车场的工作情况以及是怎么实现停车的，模拟车辆的进入停车场、离开停车场的情况，和收费情况。
三、总体设计（一）问题描述假设停车场可以停放n辆车的狭长通道，而且只有一个入口出口，汽车进入停车场的停放按照先进先放的顺序，依次排满车道。
当停车场已经停满时（已存放了n辆汽车），想进入停车场的车就只能在便道上等待，等到停车有车离开时，便道上的第一辆车进入停车场。
当停车场内的某辆车要离开时，在它后面的车必须离开让出一条道路来，待车开走后，让路的车依次进入停车场，车辆离开时，按时间缴纳费用。
（二）设计要求用栈模拟停车场，用队列模拟停车场外面的等车便道，按照终端输入数据的方式进行模拟管理。
输入1，表示车辆到达；输入2，表示车辆离开；输入3，表示列表显示停车场内外情况；输入4，表示系统帮助；输入5，表示查询车辆；输入0，表示退出程序。
车辆进入停车时，要输入车牌号码和到达时间；车辆离开时，要输入停车场车位号和离开时间，并显示应收费额；车辆查询时，要输入车牌号码；系统帮助，则是一些关于本系统的操作介绍。
（三）数据结构本课程设计使用的数据结构有：顺序栈和链式队列。
数据结构-停车场管理系统实验报告
数据结构-停车场管理系统实验报告数据结构停车场管理系统实验报告一、实验目的本次实验旨在通过设计和实现一个停车场管理系统，深入理解和应用数据结构的知识，包括栈、队列、链表等，提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、需求分析1、停车场内有固定数量的停车位。
2、车辆进入停车场时，记录车辆信息（车牌号、进入时间）。
3、车辆离开停车场时，计算停车费用并输出相关信息。
4、能够显示停车场内车辆的停放情况。
四、数据结构设计1、为了实现车辆的先进先出，选择队列来存储停车场内的车辆信息。
2、用栈来存储临时停放的车辆信息，以便在停车场已满时进行处理。
五、算法设计1、车辆进入停车场检查停车场是否已满。
如果未满，将车辆信息加入队列，并记录进入时间。
2、车辆离开停车场在队列中查找要离开的车辆。
计算停车时间和费用。
将车辆从队列中删除。
3、显示停车场内车辆停放情况遍历队列，输出车辆信息。
六、主要代码实现｀｀｀cppinclude ＜iostream>include ＜string>include ＜ctime>using namespace std;／／车辆结构体struct Car ｛string licensePlate; ／／车牌号time_t entryTime; ／／进入时间｝；／／队列类class Queue ｛private:Car data;int front, rear, capacity;public:Queue(int size) ｛capacity ＝ size;data ＝ new Carcapacity;front ＝ rear ＝ 0;｝～Queue(）｛delete data;｝bool isFull(）｛return （rear ＋ 1) ％ capacity ＝＝ front;｝bool isEmpty(）｛return front ＝＝ rear;｝void enqueue(Car car) ｛if （isFull(））｛cout ＜＜＂停车场已满！＂＜＜ endl; return;｝datarear ＝ car;rear ＝（rear ＋ 1) ％ capacity;｝Car dequeue(）｛if （isEmpty(））｛cout ＜＜＂停车场为空！＂＜＜ endl;return Car(）；｝Car car ＝ datafront;front ＝（front ＋ 1) ％ capacity;return car;｝void display(）｛if （isEmpty(））｛cout ＜＜＂停车场内没有车辆。
数据结构课程设计 停车场模拟管理系统报告(含源码)
《数据结构课程设计》报告专业：软件工程班级： T1123-03学号:姓名: XXX课设题目:停车场模拟管理系统指导教师：马春江成绩：2013-07-03目录一、设计题目 (1)二、设计目的 (1)三、总体设计 (1)（一）问题描述 (1)（二）设计要求 (1)(三）数据结构 (1)四、详细设计 (2)(一）分析与实现 (2)（二)系统模块设计 (2)（三）界面设计 (3)五、设计结果与分析 (4)六、总结（收获和不足） (5)（一）课设的不足 (5)（二)课设的收获 (5)附录程序源码 (5)参考文献： (16)指导教师意见 (17)一、设计题目停车场模拟管理系统。
二、设计目的利用所学的知识，模拟设计一个停车场管理系统.通过程序设计，了解停车场的工作情况以及是怎么实现停车的，模拟车辆的进入停车场、离开停车场的情况，和收费情况。
三、总体设计（一）问题描述假设停车场可以停放n辆车的狭长通道，而且只有一个入口出口，汽车进入停车场的停放按照先进先放的顺序，依次排满车道。
当停车场已经停满时(已存放了n辆汽车)，想进入停车场的车就只能在便道上等待，等到停车有车离开时，便道上的第一辆车进入停车场.当停车场内的某辆车要离开时,在它后面的车必须离开让出一条道路来，待车开走后，让路的车依次进入停车场，车辆离开时，按时间缴纳费用。
(二）设计要求用栈模拟停车场，用队列模拟停车场外面的等车便道，按照终端输入数据的方式进行模拟管理。
输入1，表示车辆到达；输入2，表示车辆离开；输入3,表示列表显示停车场内外情况;输入4，表示系统帮助;输入5，表示查询车辆；输入0，表示退出程序.车辆进入停车时，要输入车牌号码和到达时间；车辆离开时,要输入停车场车位号和离开时间，并显示应收费额;车辆查询时，要输入车牌号码；系统帮助，则是一些关于本系统的操作介绍.（三)数据结构本课程设计使用的数据结构有:顺序栈和链式队列.四、详细设计(一）分析与实现1、模拟停车场的车辆进出需要输入车辆的信息，比如车辆的车牌号码、到达时间、离开时间，因此，可以定义一个车辆信息结点类型和一个时间节点类型,在顺序栈和链式队列中定义结点类型为车辆信息结点类型。
停车场数据结构实验报告附代码
数据结构实验报告——实验三停车场模拟管理程序的设计与实现本实验的目的是进一步理解线性表的逻辑结构和存储结构，进一步提高使用理论知识指导解决实际问题的能力。
一、【问题描述】设停车场只有一个可停放几辆汽车的狭长通道，且只有一个大门可供汽车进出。
汽车在停车场内按车辆到达的先后顺序依次排列，若车场内已停满几辆汽车，则后来的汽车只能在门外的便道上等候，一旦停车场内有车开走，则排在便道上的第一辆车即可进入；当停车场内某辆车要离开时，由于停车场是狭长的通道，在它之后开入的车辆必须先退出车场为它让路，待该车辆开出大门，为它让路的车辆再按原次序进入车场。
在这里假设汽车不能从便道上开走，试设计这样一个停车场模拟管理程序。
为了以下描述的方便，停车场的停车场用“停车位”进行叙述，停车场的便道用“便道”进行叙述。
二、【数据结构设计】1、为了便于区分每辆汽车并了解每辆车当前所处的位置，需要记录汽车的牌照号码和汽车的当前状态，所以为汽车定义一个新的类型CAR，具体定义如下：typedef struct{char *license //汽车牌照号码，定义为一个字符指针类型char state; //汽车当前状态，字符s表示停放在停车位上，//字符p表示停放在便道上，每辆车的初始状态用字符i来进行表示}2、①由于车位是一个狭长的通道，所以不允许两辆车同时出入停车位，当有车到来要进入停车位的时候也要顺次停放，当某辆车要离开时，比它后到的车要先暂时离开停车位，而且越后到的车就越先离开停车位，显然这和栈的“后进先出”特点相吻合，所以可以使用一个栈来描述停车位。
由于停车位只能停放有限的几辆车，而且为了便于停车场的管理，为每个车位要分配一个固定的编号，不妨设为1、2、3、4、5（可利用数组的下标），分别表示停车位的1车位、2车位、3车位、4车位。
5车位，针对这种情况使用一个顺序栈比较方便。
②当某辆车要离开停车场的时候，比它后进停车位的车要为它让路，而且当它开走之后让路的车还要按照原来的停放次序再次进入停车位的某个车位上，为了完成这项功能，再定义一个辅助栈，停车位中让路的车依次“压入”辅助栈，待提出开走请求的车开走后再从辅助栈的栈顶依次“弹出”到停车位中。
数据结构实验报告模拟停车场管理
数据结构实验报告模拟停车场管理实验目的：通过模拟停车场管理的过程，理解数据结构的应用和实际工程问题的解决思路。
实验内容：1.设计停车场类和车辆类，并实现相关操作方法。
2.模拟停车场管理的过程，包括车辆的进入和离开。
3.根据实际需求设计停车场管理算法，如何选择停车位和调度车辆等。
实验步骤：1.设计停车场类停车场类需要保存停车位的信息，可以使用数组或链表实现。
需要提供以下方法：- void addCar(Car car)：将车辆添加到停车场，如果停车场已满，则禁止入场。
- void removeCar(Car car)：将车辆从停车场移除，并更新停车位信息。
- int getAvailableSpaces(：返回停车场中当前可用的停车位数量。
2.设计车辆类车辆类需要保存车辆的信息，如车牌号、车型等。
3.实现停车场管理算法停车场管理需要考虑车辆进入和离开的顺序，以及停车位的选择等问题。
可以使用队列或堆栈等数据结构来保存车辆的进出顺序。
停车位的选择可以根据具体算法进行，如先到先得、最近最便等原则。
4.完成模拟停车场管理过程的代码根据实际需求，编写代码模拟车辆进入和离开停车场的过程。
可以通过输入车辆信息和操作指令来模拟。
5.测试与优化对停车场管理算法进行测试，并根据实际情况进行优化。
可以通过增加数据量、调整车辆进出顺序等方式进行测试，并根据测试结果进行优化。
实验结果：经过实验测试，停车场管理系统可以良好地处理车辆的进入和离开，并正确计算可用停车位的数量。
通过合理的停车位选择算法，确保了车辆进出的顺序。
实验总结：通过本次实验，我们学习了如何利用数据结构来实现停车场管理系统。
停车场管理系统是一种常见的实际应用，对于解决停车难问题具有重要意义。
在实验过程中，我们掌握了设计和实现停车场类、车辆类以及停车场管理算法的方法，加深了对数据结构的理解和应用。
在实验过程中，我们还发现停车场管理算法可以通过不同的策略进行优化，如最大化停车利用率、最小化顾客等待时间等。
停车场管理程序实验报告
停车场管理程序实验报告一实验题目: 停车场管理程序二实验要求:编写一个程序实现停车场的管理功能。
并且，以栈模拟停车场，以队列模拟车场外到达便道的过程，按照从终端读入的输入数据序列进行模拟管理。
栈以顺序结构实现，队列顺序循环结构实现。
用户输入的命令有以下5种：（1）汽车到达；（2）汽车离去输出停车场中的所有汽车牌号；（3）输出候车场中的所有汽车牌号；（4）退出系统运行。
三实验内容:3.1 栈的抽象数据类型:ADT Stack{数据对象：D={ai|ai∈ElemSet, i=1,2, …,n, n≥0}数据关系：R1={<ai-1,ai>|ai-1,ai∈D, i=1,2, …,n }约定an端为栈顶，a1端为栈底。
基本操作：{InitStack( &S )操作结果：构造一个空栈S。
DestroyStack ( &S )初始条件：栈S已存在。
操作结果：销毁栈S。
ClearStack( &S )初始条件：栈S已存在。
操作结果：将S清为空栈。
StackEmpty( S )初始条件：栈S已存在。
操作结果：若S为空栈，则返回TRUE，否则返回FALSE。
StackLength( S )初始条件：栈S已存在。
操作结果：返回S的数据元素个数，即栈的长度。
GetTop( S, &e )初始条件：栈S已存在且非空。
操作结果：用e返回S的栈顶元素。
Push( &S, e )初始条件：栈S已存在。
操作结果：插入元素e为新的栈顶元素。
Pop( &S, &e )初始条件：栈S已存在且非空。
操作结果：删除S的栈顶元素，并用e返回其值。
StackTraverse( S, visit() )初始条件：栈S已存在且非空。
操作结果：从栈底到栈顶依次对S的每个数据元素调用函数visit()。
一旦visit()失败，则操作失败。
}ADT Stack3.2存储结构的定义;#define N 3#define M 4#define price 2typedef struct{int carno[N];int cartime[N];int top;}SqStack;typedef struct{int carno[M];int front,rear;}SqQueue;3.3基本操作实现:/* 创建栈 */void InitStack(SqStack *&s){s = (SqStack *)malloc(sizeof(SqStack)); s->top = -1;}/* 摧毁栈 */void DestroyStack(SqStack *&s){free(s);}/* 查看栈是否为空 */bool StackEmpty(SqStack *s){return s->top==-1;}/* 进栈 */bool Push(SqStack *&s,int e1,int e2){if(s->top == N - 1){return false;}s->top++;s->carno[s->top] = e1;s->cartime[s->top] = e2;// printf(">>停车场中位置：%d\n",e1);return true;}bool StackFull(SqStack *s){return s->top == N-1;}/* 出栈 */bool Pop(SqStack *&s,int &e1,int &e2){if(s->top == -1)return false;e1 = s->carno[s->top];e2 = s->cartime[s->top];s->top--;return true;}void DispStack(SqStack *s){printf(" >>停车场中的车辆为：");int i;for(i = s->top; i >= 0; --i){printf("%d ",s->carno[i]);}printf("\n");}/***************** 以下为队列 *****************//* 初始化队列 */void InitQueue(SqQueue *&q){q = (SqQueue *)malloc(sizeof(SqQueue));q->front=q->rear=0;}/* 释放队列 */void DestroyQueue(SqQueue *&q){free(q);}/* 查看队列是否为空 */bool QueueEmpty(SqQueue *q){return q->front == q->rear;}bool QueueFull(SqQueue *q){return (q->rear + 1)% M == q->front; }/* 进队 */bool enQueue(SqQueue *&q,int e){if((q->rear + 1) % M == q->front)return false;q->rear=(q->rear + 1)%M;q->carno[q->rear] = e;return true;}/* 出队 */bool deQueue(SqQueue *&q,int &e){if(q->front == q->rear)return false;q->front = (q->front + 1) % M;e = q->carno[q->front];return true;}3.4解题思路：1.通过栈模拟停车场2.通过队列模拟候车场3.然后全程模拟即可。
c++数据结构,停车场系统 实验报告
HDU 软件工程学院《程序设计实践(下)》设计报告姓名学号专业班级10级软件工程6班提交日期成绩指导教师问题解析（对问题的分析、解题思路与解题方法）题目一: 停车场管理系统[实验目的]综合运用线性表、队列、排序、随机数等数据结构知识，掌握并提高分析、设计、实现及测试程序的综合能力。
[实验内容及要求]停车场拥有M个车位和一条进入停车场的便道，便道上最多停放N辆汽车。
汽车要想进入车位，首先进入便道等候。
若有空闲车位，则停车入位，否则在便道继续等候，直至有车位空出。
若便道已经停满等候的汽车，后到达的汽车只能离开，选择其他停车场。
设计一个停车场管理系统，模拟停车场的运作，并统计停车场的收入。
（1）使用随机数产生某一时间段内进入和离开停车场的车辆数目；（2）存储并记录如下数据项：汽车到达和离去的时间及汽车的车号；（3）车辆到达时，提示汽车的停车位置编号（为车辆分配编号最小的可用车位），若车位已满给出相应提示；（4）汽车离去时，输出汽车在停车场内停留的时间和应交纳的费用。
（5）对该停车场进行统计：统计每天到达、离开的车次，停车总时数、每天停车场的收入等。
[问题分析]停车场系统，可以利用之前写过的队列，链表，排序等知识实现模拟，可以手工输入车的牌号和进入时间，但是这样可能给测试人员带来一定的麻烦，我们可以利用随机数字定义一个数组来实现车牌的分配和时间的分配，车牌利用五位数来简单模拟，前两位用英文字母后三位用数字，这样分配的车牌有26*26*10*10*10=676000种可能，所以不用检查车牌号是否相同，这样就节省了很多用来查找的时间。
[解决思路]1、可以用队列模拟便道，利用入队列，出队列完成车辆的进入和离开的模拟。
题目要求，进入便道不计费，可以仅仅记录车牌来实现2、可用车位需按照编号排序，申请车位时分配编号最小的车位，可用车位动态变化，可以选择利用堆排序来实现，当出来一个车的时候，3、利用rand（）随机产生随机数，来完成每小时进入车场的车辆和离开的车辆，对于车辆一小时离开的概率为25%，增加一小时离开的概率多加25%，可以用累加的形式，当车辆进入的时候，就分配给车辆一个参数，这个参数用来实现车辆在车场中的停留时间的记录4、车场刚开始，初始化的时候，就按顺序分配一些车场位置编号，用来记录与车牌对应的位置，停车场还有个参数，用来记录，此位置是否有车，如果有车就设置为true，如果没车就为false，用来统计车场中的车辆5、统计离开的车辆，当车辆离开的时候，就把参数设置为false[任务分工及进度计划]12月10号上午八点半-12月10中午完成类的设计，以及设计思路12月10号下午-12月11号全天完成类的实现12月11号-12月13号中间的空闲时间完成界面的美化和测试12月17号晚上-12月18号完成哈弗曼译码的设计和实现，由于之前这个程序已经写过，设计和编写都节省了很多时间12月19号-12月20号完成实验报告[数据结构选择、算法设计（伪代码，算法思想）]数据结构中设计到的算法有：1.队列2、链表（用结构体代替）--------------------------------------------主体函数---------------------------------------------#include <cstdlib>#include <iostream>#include "Car.h"#include "SeqQueue.h"#include"Park.h"#include <windows.h>#include <ctime>----------------------------------------------------------------------------------------------class Car{private:string chepai;string jinru_time;string likai_time;double begin;double end;double cost_money;public:Car();void shuruchepai(string );void jinru(string );void likai(string );void cost(double cost);double huafei();string getchepai()string getjinru(）string getlikai(）};--------------------------------------------------------------------------------------------emplate<class T>class SeqQueue{private:int front,rear;T *elem;int size;int len;public:SeqQueue(int size);~SeqQueue();bool IsEmpty();void enqueue(T x);T dequeue();int num();};-------------------------------------------------------------------------------------------------class Park{private:string chepai;string jinru_time;char likai_time[9];string likai2;double begin;double end;double cost_money;bool isempty;int stay_time;int times_likai;int weizhihaoma;double sum_money;public:Park(){ isempty=false;stay_time=0;times_likai=0;sum_money=0;}void shuruchepai(string a)void jinru(string a)-void weizhi(int a)void haha(string a)string gethaha()void sum_money1(double a)double money1(）void likai(int k)void cost(double cost)double huafei()string getchepai()string getjinru()char* getlikai()void run()int getweizhihaoma()void setweizhihaoma(int a)void goaway()};---------------------------------------------------------------------------------------------class Che{public:Che();void ShuRuChePai(string);//输入车牌void JinRu(string);//输入车进入停车场的时间void LiKai(string);//输入车离开停车场的时间bool Compare(string);double ShuChuM(double);private:string s;//车牌号记录double st;//车到停车场的时间double et;//车离开停车场的时间};//车的类------------------------------------------------------------------------------------------------[测试方法、测试数据与测试结果]测试方法：需要输入停车场的停车位的数量和便道中可以等待的车位的数量，以及每小时停留在停车场中的花费。
数据结构实践报告--停车场管理系统
河南财经政法大学集中实践报告院系：班级：指导老师：小组：小组成员：目录（一）设计目的 (3)（二）问题描述 (3)（三）概要设计 (4)（四）详细设计 (8)（五）调试分析 (9)（六）测试分析 (10)（七）心得体会 (11)（八）附录（源代码） (12)（一）设计目的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’表示到达（arrival）；‘D’表示离去（departure）；‘E’表示输出结束（end）。
实现提示需另设一个栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车，也用顺序存储结构实现。
输入数据按到达或离去的时刻有序。
栈中每个元素表示一辆汽车，包含两个数据项：汽车的牌照号码和进入停车场的时刻。
此外还要实现：（1）两个栈共享空间，思考应开辟数组的空间是多少？（2）汽车可有不同种类，则他们的占地面积不同，收费标准也不同，如1辆客车和1.5辆小汽车的占地面积相同，1辆十轮卡车占地面积相当于3辆小汽车的占地面积。
数据结构课程设计停车管理系统实验报告【范本模板】
数据结构课程设计报告项目名称：停车管理系统姓名：鉏飞祥学号：E21414018专业：软件工程2016-6-28安徽大学计算机科学与技术学院1 .需求分析1.1问题描述停车场内只有一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出.汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在停车场的最北端），若车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走,则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后开入的车辆必须先退出车场为它让路,待该辆车开出大门外，其它车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用.试为停车场编制按上述要求进行管理的模拟程序.1。
2基本要求(1)输入的形式和输入值的范围;七位字符车牌号空格时间(12:30)如：A123456 12：30(2)输出的形式；车牌号时间如：A123456 12：30(3)程序所能达到的功能.模拟车子排队和进出车库的情况,并且根据时间计费，随时显示当前车库车辆情况。
2. 概要设计（1）数据结构每个汽车的基本元素：struct car｛char id［8］；int h;/＊时＊/int m；/*分＊/struct car ＊next;｝;栈的基本元素:struct sqstack{struct car ＊base；struct car ＊top；int stacksize;};（2）程序模块void intstack（struct sqstack &S）/＊构造栈＊/void push_stack(struct sqstack ＆S，struct car ＊e) /＊e入栈*/void pop_stack(struct sqstack ＆S，struct car *e）/*出栈顶元素到e＊/void creat_q（）/*创建队列*/void push_q（struct car *p）/＊车辆入队*/struct car ＊ pop_q(）/＊车辆出队*/void come_in（)/＊车辆离开*/void go_out（）/＊车辆进入*/void interface(）/*主菜单*/(4)各模块之间的调用关系以及算法设计3. 详细设计流程图及模块调用如下：4. 测试与分析主界面如下：车库中假设最多停三辆车,加入进入四辆车abcd，则d需要在便道排队：此时若b车开走，显示费用信息,则在便道的d车进入车库：若此时有车进入，则继续在便道排队：5。
数据结构停车场实习报告
一、实习背景随着我国经济的快速发展，城市车辆数量逐年攀升，停车难问题日益突出。
为了解决这一问题，我们需要设计一个高效、便捷的停车场管理系统。
本次实习以数据结构为基础，设计并实现了一个停车场管理系统。
二、实习目的1. 理解并掌握数据结构在实际问题中的应用；2. 提高编程能力和算法设计能力；3. 掌握停车场管理系统的设计与实现方法；4. 分析并解决实际问题。
三、系统设计1. 系统功能（1）车辆进出管理：实现车辆进入和离开停车场的功能，包括记录车辆信息、计算停车费用等。
（2）车位管理：实时显示停车场内剩余车位数量，实现车位分配和回收。
（3）数据统计：统计停车场使用情况，包括车辆进出次数、停车时间等。
（4）异常处理：处理车辆进出异常情况，如超时、非法操作等。
2. 数据结构设计（1）停车场：使用栈结构存储停车场内的车辆信息，栈底为停车场最里面，栈顶为停车场最外面。
（2）便道：使用队列结构存储便道上的车辆信息，队列头为便道最外面，队列尾为便道最里面。
（3）车辆信息：包括车辆牌照、进入时间、离开时间、停车费用等。
3. 算法设计（1）车辆进入停车场：判断停车场是否已满，若不满，则将车辆信息压入栈中；若满，则将车辆信息入队。
（2）车辆离开停车场：判断便道是否为空，若为空，则从栈中弹出车辆信息；若不为空，则从队列中出队车辆信息。
（3）计算停车费用：根据车辆停留时间计算停车费用。
四、实习过程1. 需求分析：了解停车场管理系统的基本需求，确定系统功能。
2. 设计阶段：设计系统架构、数据结构、算法等。
3. 编码阶段：根据设计文档，使用C++语言进行编程实现。
4. 测试阶段：编写测试用例，对系统进行功能测试、性能测试等。
5. 调试阶段：针对测试过程中发现的问题进行调试和优化。
五、实习结果1. 系统功能实现：停车场管理系统已实现车辆进出管理、车位管理、数据统计、异常处理等功能。
2. 数据结构应用：成功将栈和队列应用于停车场管理系统，提高了系统性能。
数据结构 停车场管理报告
实验二：停车场管理（栈和队列应用）班级学号姓名一、实验目的1 掌握队列和栈顺序存储结构和链式存储结构，以便在实际背景下灵活运用。
2 掌握栈和队列的特点，即先进后出与先进先出的原则。
3 掌握栈和队列的基本运算。
二、实验内容1 问题描述设有一个可以停放n辆汽车的狭长停车场，它只有一个大门可以供车辆进出。
车辆按到达停车场时间的早晚，依次从停车场最里面向大门口处停放。
如果停车场已放满n辆车，则后来的车辆只能在停车场大门外的便道上等待，一旦停车场内有车开走，则排在便道上的第一辆车就进入停车场。
停车场内如有某辆车要开走，在它之后进入停车场的车都必须退出停车场为它让路，待其开出停车场后，这些车辆再依原来的次序进场。
每辆车在离开停车场时，都应根据它在停车场内停留的时间长短来交费。
如果停留在便道上的车未进入停车场就要离去，允许其离开，不收停车费，并且仍然保持在便道上等待的车辆次序。
编制一个程序模拟该停车场的管理。
2 实现要求要求程序输出每辆车到达后的停车位置（停车场或便道），以及某辆车离开停车场时应该交纳的费用和它在停车场内停留的时间。
3 实现提示汽车的模拟输入信息格式可以为：（到达/离开，汽车牌照号码，到达/离开的时间）。
用栈和队列来模拟停车场和便道。
三、实验结果：头文件#define MAXSIZE 3#define price 0.4typedef struct time {int hour;int min;}Time;typedef struct car {char num[10];Time reach;Time leave;}CarNode;typedef struct SNode {CarNode *data1[MAXSIZE+1];int top;}SeqStackCar;typedef struct QNode {CarNode *data2;struct QNode *next;}QueueNode;typedef struct LQNode {QueueNode *front;QueueNode *rear;}LinkQueueCar;void InitStack(SeqStackCar *s);int InitQueue(LinkQueueCar *Q);void Display(CarNode *p,int place);int Arrival(SeqStackCar *s,LinkQueueCar *LQ);void Leave1(SeqStackCar *s1,SeqStackCar *s2,LinkQueueCar *LQ); void Leave2(LinkQueueCar *LQ);void List1(SeqStackCar *s);void List2(LinkQueueCar *LQ);源文件#include "car.h"#include<iostream>using namespace std;int i=0;void InitStack(SeqStackCar *s){int i;s->top=0;for(i=0;i<=MAXSIZE;i++)s->data1[s->top]=NULL;}int InitQueue(LinkQueueCar *Q){Q->front=new QueueNode;if(Q->front!=NULL){Q->front->next=NULL;Q->rear=Q->front;return 1;}elsereturn 0;}void Display(CarNode *p,int place){int A1,A2,B1,B2,time;cout<<"请输入离开的时间:";cin>>p->leave.hour;cin>>p->leave.min;while(p->leave.hour<p->reach.hour||p->leave.hour>23){cout<<"error!"<<endl;cout<<"请输入离开的时间:";cin>>p->leave.hour;cin>>p->leave.min;}cout<<endl;cout<<"离开车辆的车牌号为:";cout<<p->num<<endl;cout<<"其到达时间为: "<<p->reach.hour<<":"<<p->reach.min<<endl;cout<<"其离开时间为: "<<p->leave.hour<<":"<<p->leave.min<<endl;A1=p->reach.hour;A2=p->reach.min;B1=p->leave.hour;B2=p->leave.min;time=(B1-A1)*60+(B2-A2);cout<<"该车停在停车场中的时间:"<<time<<"分钟!"<<endl;cout<<"应交费用为: "<<time*price<<"元!"<<endl;cout<<endl;}int Arrival(SeqStackCar *s,LinkQueueCar *LQ){CarNode *p;QueueNode *t;p=new CarNode;cout<<"请输入车牌号(例:A1234):";cin>>p->num;if(s->top<MAXSIZE){s->top++;cout<<"车辆在车场第"<<s->top <<"位置!"<<endl;cout<<"请输入到达时间:";cin>>p->reach.hour;cin>>p->reach.min;while(p->reach.hour<0||p->reach.hour>23||p->reach.min<0||p->reach.min>59) {cout<<"error!"<<endl;cout<<"请输入到达时间:";cin>>p->reach.hour;cin>>p->reach.min;}s->data1[s->top]=p;return 1;}else{cout<<"该车停在便道上!"<<endl;t= new QueueNode;t->data2=p;t->next=NULL;LQ->rear->next=t;LQ->rear=t;i++;cout<<"车辆在便道"<<i<<"个位置!"<<endl;return 1;}}void Leave1(SeqStackCar *s1,SeqStackCar *s2,LinkQueueCar *LQ) {int place;CarNode *p,*t;QueueNode *q;if(s1->top>0){while(1){cout<<"请输入车在车场的位置1--"<<s1->top<<":";cin>>place;if(place>=1&&place<=s1->top) break;}while(s1->top>place){s2->top++;s2->data1[s2->top]=s1->data1[s1->top];s1->data1[s1->top]=NULL;s1->top--;}p=s1->data1[s1->top];s1->data1[s1->top]=NULL;s1->top--;while(s2->top>=1){s1->top++;s1->data1[s1->top]=s2->data1[s2->top];s2->data1[s2->top]=NULL;s2->top--;}Display(p,place);if((LQ->front!=LQ->rear)&&s1->top<MAXSIZE){q=LQ->front->next;t=q->data2;s1->top++;cout<<"便道的"<<t->num<<"号车进入车场第"<<s1->top<<"位置!"<<endl;cout<<"请输入到达的时间:";cin>>t->reach.hour;cin>>t->reach.min;if(t->reach.hour<0||t->reach.hour>23||t->reach.min<0||t->reach.min>59){cout<<"error!"<<endl;cout<<"请输入到达时间:";cin>>t->reach.hour;cin>>t->reach.min;}LQ->front->next=q->next;if(q==LQ->rear)LQ->rear=LQ->front;s1->data1[s1->top]=t;delete q;}elsecout<<"便道里没有车!"<<endl;}elsecout<<"停车场里没有车!"<<endl;}void Leave2(LinkQueueCar *LQ){QueueNode *q;CarNode *t;if(LQ->front!=LQ->rear){q=LQ->front->next;t=q->data2;LQ->front->next=q->next;if(q==LQ->rear)LQ->rear=LQ->front;delete q;cout<<"便道上车牌号为"<<t->num<<"的车从便道上离开!"<<endl;}elsecout<<"便道里没有车!"<<endl;}void List1(SeqStackCar *s){int i;if(s->top>0){cout<<" 位置到达时间车牌号"<<endl;for(i=1;i<=s->top;i++){cout<<" "<<i<<" "<<s->data1[i]->reach.hour<<":"<<s->data1[i]->reach.min<<" "<<s->data1[i]->num<<endl;}}elsecout<<"停车场里没有车!"<<endl;}void List2(LinkQueueCar *LQ){QueueNode *p;p=LQ->front->next;if(LQ->front!=LQ->rear){cout<<"便道上车的车牌号为:"<<endl;while(p!=NULL){cout<<p->data2->num<<endl;p=p->next;}}elsecout<<"便道上没有车!"<<endl;}测试文件#include "car.h"#include<iostream>using namespace std;void main(){SeqStackCar s1,s2;LinkQueueCar LQ; int m;InitStack(&s1);InitStack(&s2);InitQueue(&LQ);while(1){cout<<"★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★"<<endl;cout<<"1.车辆到达2.离开停车场3.离开便道4.停车场列表5.便道列表6.退出系统"<<endl;cout<<"★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★"<<endl;cin>>m;switch(m){case 1:Arrival(&s1,&LQ);break;case 2:Leave1(&s1,&s2,&LQ);break;case 3:Leave2(&LQ);break;case 4:List1(&s1);break;case 5:List2(&LQ);break;case 6:exit(0);default: break;}}}（两运行结果：个图表联在一起）四、实验总结1．学会了栈和队列的综合使用，更加灵活运用栈和队列。
数据结构课程设计实验报告-模拟停车场管理问题
数据结构课程设计题目：模拟停车场管理问题2020 年6 月 25 日·北京信息工程学院信息技术教学与实验中心二、目录目录二、目录 (1)三、设计任务书 (2)四、小组成员及分工 (3)五、报告正文 (3)1.设计题目 (3)2.设计目的 (3)3.算法思想分析 (3)4.算法描述与实现 (4)5.程序运行结果 (10)6.结论 (11)三、设计任务书课程设计名称：数据结构课程设计课程设计编号：CST206课程设计学分：2课程设计周（时）数：2周课程设计授课单位：信息工程学院计算机系指导方式：集体辅导与个别辅导相结合课程设计适用专业：计算机科学与技术课程设计教材及主要参考资料：《数据结构课程设计》，滕国文编著，清华大学出版社，2010年；《数据结构课程设计》，陈越钦铭雁编著，浙江大学出版社，2009年《数据结构课程设计案例教程》, 马巧梅等编著, 人民邮电出版社，2012年题目1：模拟停车场管理问题问题描述：设停车场只有一个可停放几辆汽车的狭长通道，且只有一个大门可供汽车进出。
汽车在停车场按车辆到来的先后顺序依次排列，若车场内已停满几辆汽车，则后来的汽车只能在门外的便道上等候，一旦停车场内有车开走，则排在便道上的第一辆车即可进入；当停车场内某辆车要离开时，由于停车场是狭长的通道，在它之后开入的车辆必须先退出车场为它让路，待该辆车开出大门后，为它让路的车辆再按原次序进入车场。
每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。
基本要求：试为停车场编制按上述要求进行管理的模拟程序。
在这里假设汽车不能从便道上开走。
试设计一个停车场管理程序。
实现提示：以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。
每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时刻，例如：('A',1,5)表示一号牌照车在5这个时刻到达，而('D',5,20)表示5号牌照车在20这个时刻离去，整个程序可以在输入信息为('E',0,0)时结束。
c语言数据结构停车场系统实验报告
实验题目：实验六停车场管理一、需求分析1．程序的功能：设停车场内只有一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。
汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列〔大门在最南端，最先到达的第一辆车停放在车场的最北端〕，假设车场内已停满n辆汽车，那么后来的汽车只能在门外的便道上等候，一旦有车开走，那么排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后开入的车辆必须先退出车场为它让路，待该辆车开出大门外，其它车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。
〔1〕建立静态数组栈作为模拟停车场，动态链表栈作为模拟便道。
〔2〕车辆到达，停入停车场或者便道，记录车牌号，到达时间。
〔3〕车辆离开，记录离开时间，输出停车时间和收费。
将便道内车停入停车场，记录进入时间。
〔4〕列表显示停车场，便道内车辆情况。
〔5〕列表显示历史记录〔已经离开车的车牌号，到达离开时间，收费〕。
2．输入输出的要求：（1）输入：字符串车牌号，到达时间，离开时间（2）输出：停车时间和收费，停车场和便道的停车情况，历史记录。
3．测试数据：二．概要设计4．本程序所用的抽象数据类型的定义ADT Stack{数据对象：D={ai|ai为ElemSet，i为正整数}数据关系：R1={<ai-1,ai>|ai-1,ai都属于D，i为正整数}根本操作：InitStack(&S) //构建一个空栈SDestroyStack(&S) //S 被销毁StackLength(S) //返回S 的元素个数，即栈的长度。
StackEmpty(s) //假设栈S 为空栈，那么返回TRUE，否那么FALE。
GetTop(S, &e) //用e 返回S 的栈顶元素ClearStack(&S) //将S 清为空栈Push(&S, e) //入元素e 为新的栈顶元素。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
模拟停车场管理班级：物联网姓名：XXX 学号：XXXXXXX 日期：4月9日一、需求分析1、程序的功能描述按照从终端输入的数据序列进行模拟管理。
1）狭道停车用栈来实现，并且用的顺序栈，等车位的便道用队列来实现，并用链式存储。
2）每一组输入信息包含三个数据项，汽车的“到达”和“离去”的信息，汽车牌照号码，汽车“到达”或“离去”的时刻。
3）对每一组输入数据进行操作后的输出信息为：若是车辆到达，则输出车辆在停车场内或便道上的停车位置；若是车子离去，则输出车辆在停车场内停留的时间和缴纳的费用。
（假设在便道等车的时间不收费）4）选作内容：（1）便道也是要收费的，仅仅比狭道收费便宜点。
（2）狭道上的车可以直接开走。
2、输入/输出的要求首先选择操作的模块，根据提示输入车牌和到达时间，程序会告知是否停满或者停车车位。
车牌为10个字符以内的字符串，时间的输入中间有冒号把时分隔开。
3、测试数据1 苏D543 1:101 苏Q123 1：201 苏D145 1：30二、概要设计1、本程序所用的抽象数据类型的定义typedef struct NODE{C arNode *stack[MAX+1];int top;}SeqStackCar;//狭道的堆栈顺序存储typedef struct car{C arNode *data;struct car *next;}QueueNode;//队列的链式存储typedef struct Node{Q ueueNode *head;QueueNode *rear;}LinkQueueCar;//便道上等候的队列定义2、主模块的流程及各子模块的主要功能○1车辆到达：int Arrival(SeqStackCar *Enter,LinkQueueCar *W)首先定义一个栈和队列的结构体指针为：*p , *t 。
然后申请一个车辆信息的内存空间，并把它赋给栈指针。
车辆到达时就输入车牌号，并通过if(Enter->top<MAX)来判断该车是进车场内还是进便道上，如果是进车场内就把top 加1，显示在车场内的位置，还要输入进车场的时间，然后把该节点进栈。
如果是else 就显示该车要停在便道上，并进行进队列的操作。
○2车辆离开： void Leave(SeqStackCar *Enter,SeqStackCar *Temp,LinkQueueCar *W)定义一个整型变量room 记录要离开车辆的位置，定义两个栈指针和一个队列指针，用个if(Enter->top>0) 确保栈不空，然后用个while(1) 确保输入的车辆离开位置的合法性。
如果不和法，显示输入有误，要重新输入。
通过while(Enter->top>room) 判断离开车辆的位置，如果是中间位置，就要再用一个栈前面临时开出来的车，等要开出的车开出后，再把临时栈的车看进车场内，并要调用PRINT(p,room); 这个函数计算显示费用。
然后还要用 if((W->head!=W->rear)&&Enter->top<MAX) 语句判断便道上有没有车，如果有车就要显示进车场的车的车牌号，并登记进入时间。
3、模块之间的层次关系主函数中包含着各个函数模块，各模块也在互相调用。
比如，离开函数中要计算停车费，故要调取价格函数。
价格函数计算要用到离开和进入的时间，又要调用进入和离开函数。
三、详细设计1、采用C语言定义相关的数据类型#define MAX 3 // 停车场最大容量为3辆，便于观察#define price 0.05typedef struct time{ // 定义时间结构体i nt hour;i nt min;}Time;typedef struct node{ // 定义车辆信息结构体c har num[10];Time reach;Time leave;}CarNode;2、写出各模块的伪码算法void PRINT(CarNode *p,int room){ // 车辆收费i nt A1,A2,B1,B2;p rintf("\n车辆离开的时间:");scanf("%d:%d",&(p->leave.hour),&(p->leave.min));printf("\n离开车辆的车牌号为:");puts(p->num);printf("\n其到达停车位时间);printf("\n离开停车位时间为:);A1=p->reach.hour;A2=p->reach.min;B1=p->leave.hour;B2=p->leave.min;printf("\n应交费用为: %2.1f元",((B1-A1)*60+(B2-A2))*price+PRINTE(p,room));free(p);}int Arrival(SeqStackCar *Enter,LinkQueueCar *W)//进入便道或者狭道{C arNode *p;QueueNode *t;p=(CarNode *)malloc(sizeof(CarNode));flushall();printf("\n请输入车牌号(例:豫B1234):");gets(p->num);i f(Enter->top<MAX){Enter->top++;printf("\n车辆在车场第%d位置.",Enter->top);printf("\n车辆到达时间:");scanf("%d:%d",&(p->reach.hour),&(p->reach.min));Enter->stack[top]=p;return(1);}e lse{printf("\n该车须在便道等待!有车位时进入车场");t=(QueueNode *)malloc(sizeof(QueueNode));进入队列，调整指针；printf("请输入进入便道的时间");scanf("%d:%d",&(p->reach.hour),&(p->reach.min));return(1);}}void Leave(SeqStackCar *Enter,SeqStackCar *Temp,LinkQueueCar *W) { //车辆的离开i nt room;CarNode *p,*t;QueueNode *q;i f(Enter->top>0) // 判断车场是否为空{while(1){printf("\n请输入车在车场的位置/1--%d/：",Enter->top);scanf("%d",&room);if(room>=1&&room<=Enter->top) break;else printf("\n 输入有误,请重输: ");}while(Enter->top>room) // 把要删除的车辆的前面的车开出来，进临时栈。
{Temp->top++;Temp->stack[Temp->top]=Enter->stack[Enter->top];Enter->stack[Enter->top]=NULL;Enter->top--;}p=Enter->stack[Enter->top]; //把要删除的车辆节点赋给p。
Enter->stack[Enter->top]=NULL;Enter->top--;while(Temp->top>=1) // 再把临时栈里德车辆进停车场{Enter->top++;Enter->stack[Enter->top]=Temp->stack[Temp->top];Temp->stack[Temp->top]=NULL;Temp->top--;}PRINT(p,room); // 调用计费函数计费。
if((W->head!=W->rear)&&Enter->top<MAX) //如果便道上有车，则再开进停车场。
{q=W->head->next;t=q->data;Enter->top++;scanf("%d:%d",&(t->reach.hour),&(t->reach.min));// t->leave .hour =t->reach.hour;//t->leave .min =t->reach.min;W->head->next=q->next;if(q==W->rear) W->rear=W->head;Enter->stack[Enter->top]=t;PRINTE(t,room);free(q);}else printf("\n便道里没有车.\n");}e lse printf("\n车场里没有车.");}3、画出函数的调用关系图|---------------->到达函数-----||---------------->离开函数-------->停车费用主函数----------->显示车场里的情况|---------------->显示便道里的情况四、调试分析1、调试中遇到的问题及对问题的解决方法因为时间结构体里的小时，分钟都是用的是整型，所以如果出现1：01这个时间的话，会导致显示列表是1：1；这样的话会造成人的误解，同时会导致程序对停车缴纳的费用计算错误。
解决方法1：可以用数组和或者字符串来表示时间，但是问题来了，要是用字符串的话，算停车费有点问题，要废上一段时间的，会提高复杂度。
解决方案2：将输出用右对齐方式，缺位的用0补齐，这样最快捷啦！2、算法的时间复杂度和空间复杂度由于没有进行循环嵌套之类的运算，只有简单的循环语句，所以时间复杂度T（O）=O（n）,在数据的存储方面，除了车牌号用的是数组以外，便道用的是顺序栈，这些是提前要申请一定的存储空间的，这样非动态分配的存储空间，在某些时候是会导致空间的浪费，增加其空间复杂度。