数据结构实验报告模拟停车场管理(含代码)
数据结构课程设计报告书 停车场管理系统
#include<stdio.h>#include<stdlib.h>#include<string.h>#define N 100/*预设停车场有100个车位*/#define D 1.2/*预设车辆停车费为1.2元每小时*/ #define NUMBER 100void menu();void start();void parkingplace();void drive();struc car{int carnumber;int cararrave;int carleave;int carplace;}car[NUMBER];struct park;{int null;}parkingplace[N-1];void main (){menu();/*菜单*/}void menu(){int n;do{puts("****MENU***");puts("1、停车");puts("2、开车");puts("3、退出");puts("4、初始化");printf("请选择你需要的服务(1-4):");scanf("%d",&n);}switch(n){case 1:parking;break;/*停车函数*/case 2:drive;brea ;/*开车函数*/case 3:exit;break;/*退出*/case 4:start;break;/*初始化*/}}void start()/*初始化*/{int i,j;for(i=0;j<N;i++)parking[i].null=0;/*停车场设置为空*/printf("已初始化");menu();}void parkingplace()/*车辆进入函数*/{int i,a,h=0;printf(“请输入该车系序号(从0开始):”);scanf(“%d”,&a);for(i=0;i<N;i++){if(parking[i].park==0)/*无车标记*/if(parking[i].park==1)/*有车标记*/h=h+1;}if(h==N)printf(“停车场内已满!”);else{car[a].carplace=h;parkingplace[h].null=1;printf(“该车应该停在停车场内”);printf(“请输入该车进停车场时间:”);scanf(“d%”,&car[a].cararrave);}void drive()/*车辆离开函数*/{int i,k,time;double(“请输入车辆次序号【】”);scanf(“%d”,&i);printf(“请输入离开时间:”);scanf(“%d”,&car[i]carleave);fee=D*(car[i].carleave-car[i].cardrrave);time=car[i].carleave-car[i].cardrrave;printf(“次序号为%d的车停时间%d小时,应收费%f元”,i,time,fee); }。
数据结构实验(停车场问题)
《数据结构》课程实验实验报告题目:停车场管理专业:计算机科学与几技术ﻩ班级:姓名: ﻩ学号:ﻩ完成日期:一、试验内容设停车场就是一个可以停放n辆汽车得狭长通道,且只有一个大门可供汽车进出.汽车在停车场内按车辆到达时间得先后顺序,依次由北向南排列(大门在最南端,最先到达得第一辆车停放在车场得最北端),若车场内已经停满n辆汽车,则后来得汽车只能在门外得便道上等候,一旦有车开走,则排在便道上得第一辆车即可开入;当停车场内某辆车要离开时,在它之后进入得车辆必须先退出场为它让路,待该辆车开出大门外,其她车辆再按次序进入车场,每辆停放在车场得车在它离开停车场时必须按它停留得时间长短交纳费用,试为停车场编制按上述要求进行管理得模拟程序.以栈模拟停车场,以队列模拟车场外得便道,按照从终端读入得输入数据序列进行模拟管理。
每一组输入数据包括三个数据项:汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去得时刻。
对一组输入数据进行操作后得输出信息为:若就是车辆到达,则输出汽车在停车场内或便道上得停车位置;若就是车辆离去,则输出汽车在停车场内停留得时间与应交纳得费用(在便道上停留得时间不收费)。
二、试验目得(1)深入了解栈与队列得特性,掌握栈与队列得存储方法.(2)掌握栈与队列得基本操作,如初始化、入栈(队列)、出栈(队列)等,并能在实际问题背景下灵活运用。
三、流程图四、源程序代码#include<stdio、h>#include<stdafx、h〉void main(){struct cc1{int hm1,sk1;ﻩ}a[5];//停车场struct bd{inthm2,sk2;ﻩ}b[5];//便道ﻩstruct cc2ﻩ{ﻩﻩinthm3,sk3;}c[4];//存放从停车场内退出得车int p=0,q=0,x=0,n,y,t,r,i,j,g,h,z;char m;printf(”输入停车场容量与每分钟收费\n”);ﻩscanf(”%d%d”,&n,&y);printf(”输入数据:\n");for(;;){ﻩscanf(”%c",&m);//判断输入数据ﻩﻩif(m=='e'||m==’E’)ﻩbreak;ﻩscanf("%d%d",&t,&r);//t表示车牌号,r表示时间//车到达ﻩif(m=='a'||m=='A'){ﻩif(p<n)ﻩﻩ{//n表示停车场容量,p表示场内车得数量ﻩa[p]、hm1=t;ﻩﻩﻩﻩa[p]、sk1=r;ﻩﻩprintf("车停在停车厂内%d号位置、\n",p+1);ﻩﻩﻩp++;ﻩﻩ}ﻩ//车停在便道内elseﻩﻩ{ﻩﻩb[q]、hm2=t;ﻩﻩﻩﻩb[q]、sk2=r;ﻩprintf("车停在便道上%d号位置、\n",q+1);ﻩﻩq++;ﻩﻩ}ﻩﻩ}//车离开ﻩﻩif(m==’d'||m=='D')ﻩﻩ{h=p;ﻩﻩﻩfor(i=0;i<p;i++,g=i)ﻩﻩﻩif(a[i]、hm1==t)ﻩﻩ{//判断车就是否停在场内ﻩﻩp--;ﻩﻩif(i==p)//如果车停在场内最后一位ﻩﻩﻩprintf(”%d号车在停车厂内停留了%d分钟,应交纳%d元钱、\n”,t,r-a[i]、sk1,y*(r-a[i]、sk1));ﻩelseﻩﻩ{//在它之后进入得车辆先退出场为它让路ﻩfor(j=p;j>i;j-—)ﻩﻩ{ﻩﻩﻩﻩc[x]、hm3=a[j]、hm1;ﻩﻩﻩﻩc[x]、sk3=a[j]、sk1;ﻩﻩﻩx++;ﻩﻩﻩ}ﻩﻩﻩﻩprintf(”%d号车在停车厂内停留了%d分钟,应交纳%d元钱、\n”,t,r-a[i]、sk1,y*(r—a[i]、sk1));ﻩﻩﻩﻩﻩfor(j=i;x—1〉=0;x--,j++)ﻩﻩﻩﻩ{//退出得车再进入停车场内ﻩﻩﻩﻩa[j]、hm1=c[x—1]、hm3;ﻩﻩﻩﻩﻩa[j]、sk1=c[x-1]、sk3;ﻩ}}ﻩﻩﻩﻩif(q!=0)ﻩﻩﻩﻩ{//便道内得车进入停车场ﻩﻩﻩa[p]、hm1=b[0]、hm2;ﻩﻩﻩa[p]、sk1=r;ﻩﻩﻩﻩp++;ﻩﻩﻩfor(j=0;j<q-1;j++)ﻩﻩﻩﻩ{ﻩﻩﻩb[j]、hm2=b[j+1]、hm2;ﻩﻩb[j]、sk2=b[j+1]、sk2;ﻩﻩ}ﻩq-—;ﻩﻩﻩ}ﻩbreak;}ﻩﻩﻩ//判断车就是否停在便道上ﻩﻩfor(i=0;i〈q;i++,z=q)ﻩﻩﻩif(b[i]、hm2==t)ﻩ{ﻩﻩﻩﻩprintf(”该车停留在便道内,不收费、\n");ﻩfor(j=i;j〈q-1;j++)ﻩﻩ {ﻩﻩ b[j]、hm2=b[j+1]、hm2;ﻩﻩﻩb[j]、sk2=b[j+1]、sk2;ﻩﻩ}ﻩq—-;ﻩﻩ break;ﻩﻩ}if(g==h&&i==z) printf(”无该车、\n");ﻩﻩﻩ}ﻩ}}五、调试过程调试过程中,车离开得那一部分经常出现错误,运行结果与预想得不太一样,后来发现就是停车场得计数器那出现了问题,使离开后再进入停车场得位置发生了错误.如果输入得离开时间比到达得时间小,则会出现付费为负值。
数据结构停车场管理实验报告
数据结构停车场管理实验报告一、实验目的本次实验旨在通过设计和实现一个停车场管理系统,深入理解和应用数据结构中的栈和队列等知识,提高解决实际问题的能力。
二、实验环境编程语言: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已存在。
实验三 停车场模拟管理程序的设计与实现
实验三停车场模拟管理程序的设计与实现一、问题描述设停车场只有一个可停放几辆汽车的狭长通道,只能停放五辆车,另外还有一个便道,可停放无数辆车,停车场只能单向进出,设计一个管理停车场的系统。
二、数据结构实现停车位栈:typedef struct{char name[10];}carname;typedef struct{carname car[6];int top;}seqstackcar;便道队列typedef struct node{carname car[100];int front,rear;int num;}queuenode;三、功能设计1.车进入函数void arrive(seqstackcar *stop,queuenode *lq,carname x)2.车离开函数int leave(seqstackcar *s1,seqstackcar *s2,queuenode *p,carname x)3.查询车函数void chaxun(seqstackcar *s1)四、界面设计可以为用户提供采用多选择式管理停车位使用户使用本系统方便快捷。
五、运行与调试1.汽车进入时的场景2.离开和查询时的场景3.容错检测#include<iostream.h>#include<stdlib.h>#include<string.h>#define maxsize 5typedef struct{char name[10];}carname;carname name1;typedef struct{carname car[6];int top;}seqstackcar;typedef struct node{carname car[100];int front,rear;int num;}queuenode;seqstackcar *init_car(){seqstackcar *s;s=new seqstackcar;if(!s)return NULL;else{s->top=0;return s;}}int push(seqstackcar *s,carname x) {if(s->top==maxsize)return 0;else{s->top++;s->car[s->top]=x;return 1;}carname pop(seqstackcar *s){if(s->top==0){return name1;}else{s->top--;return s->car[s->top+1];}}queuenode *initqueue(){queuenode *q;q=new queuenode;q->front=q->rear=0;q->num=0;return q;}int inqueue(queuenode *q,carname x){if(q->num==100)return 0;else{q->rear=q->rear+1;q->car[q->rear]=x;q->num++;return 1;}}carname outqueue(queuenode *q){if(q->num==0){cout<<"候车处已经没车了"<<endl;return name1;}else{q->front++;q->num--;return q->car[q->front];}}void arrive(seqstackcar *stop,queuenode *lq,carname x){int f;f=push(stop,x);if(f==1)cout<<<<"车在"<<stop->top<<"车位上"<<endl;else{inqueue(lq,x);cout<<<<"车在候车处"<<lq->rear-lq->front<<"车位上"<<endl;}}int leave(seqstackcar *s1,seqstackcar *s2,queuenode *p,carname x){char *b=;int n,f=0;carname y;char *a=;while(s1->top>0&&f!=-1){y=pop(s1);a=;if(strcmp(a,b)!=0&&[0]!='\0')n=push(s2,y);else{f=-1;break;}}if(strcmp(a,b)==0&&[0]!='\0'){cout<<<<"车已经离开停车位"<<endl;while(s2->top!=0){y=pop(s2);push(s1,y);}if(p->rear-p->front>0){y=outqueue(p);push(s1,y);}elsecout<<"候车处没有车"<<endl;}else{cout<<"没有此车"<<endl;while(s2->top!=0){push(s1,y);y=pop(s2);}}return 0;}void chaxun(seqstackcar *s1){if(s1->top==0)cout<<"停车位没有车"<<endl;else{for(int i=1;i<=s1->top;i++)cout<<s1->car[i].name<<"在"<<i<<"车位"<<endl;}}int main(){char ch;seqstackcar *s1,*s2;queuenode *p;int flag;s1=init_car();s2=init_car();p=initqueue();flag=1;while(1){cout<<"请输入字母,A:车进入,L:车退出,E:退出,P:查询"<<endl;cin>>ch;switch(ch){case 'A':{carname q;cout<<"请输入车的名字"<<endl;cin>>;arrive(s1,p,q);}break;case 'L':{carname q1;cin>>;leave(s1,s2,p,q1);}break;case 'E':{cout<<"exit"<<endl;flag=0;}break;case 'P':chaxun(s1);break;default:cout<<"输入错误请重新输入!"<<endl;if(flag==0)break;}}return 0;}。
数据结构停车场管理实验报告
停车场管理实验报告姓名:学号:学院:继续教育学院班级:计算机科学与技术一.实验目的和要求熟练栈和队列的结构特性,掌握在实际问题背景下的应用二.实验主要内容以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入的输入数据序列进行模拟管理。
每一组输入数据包括三个数据项:汽车“达到”或“离去”信息、汽车牌照号码以及达到或离去的时刻。
对每一组输入数据进行操作后的输出信息为:若是车辆达到、则输出汽车在停车场内或便道上停车位置;若是车辆离去,则输出汽车在停车场内停留的时间和应交纳的费用(在便道上停留的时间不收费)。
栈以顺序结构实现,队列以链表结构实现。
三.实验仪器和环境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、模拟停车场的车辆进出需要输入车辆的信息,比如车辆的车牌号码、到达时间、离开时间,因此,可以定义一个车辆信息结点类型和一个时间节点类型,在顺序栈和链式队列中定义结点类型为车辆信息结点类型。
数据结构停车场问题实验报告
数据结构课程设计——停车场管理问题姓名:学号:一、问题描述设有一个可以停放n辆汽车的狭长停车场,它只有一个大门可以供车辆进出。
车辆按到达停车场时间的早晚依次从停车场最里面向大门口处停放(最先到达的第一辆车放在停车场的最里面)。
如果停车场已放满n辆车,则后来的车辆只能在停车场大门外的便道上等待,一旦停车场内有车开走,则排在便道上的第一辆车就进入停车场。
停车场内如有某辆车要开走,在它之后进入停车场的车都必须先退出停车场为它让路,待其开出停车场后,这些车辆再依原来的次序进场。
每辆车在离开停车场时,都应根据它在停车场内停留的时间长短交费。
如果停留在便道上的车未进停车场就要离去,允许其离去,不收停车费,并且仍然保持在便道上等待的车辆的次序。
编制一程序模拟该停车场的管理。
二、实现要求要求程序输出每辆车到达后的停车位置(停车场或便道上),以及某辆车离开停车场时应交纳的费用和它在停车场内停留的时间。
三、实现提示汽车的模拟输入信息格式可以是:(到达/离去,汽车牌照号码,到达/离去的时刻)。
例如,(‘A’,,1,5)表示1号牌照车在5这个时刻到达,而(‘D’,,5,20)表示5号牌照车在20这个时刻离去。
整个程序可以在输入信息为(‘E’,0,0)时结束。
本题可用栈和队列来实现。
四、需求分析停车场采用栈式结构,停车场外的便道采用队列结构(即便道就是等候队列)。
停车场的管理流程如下①当车辆要进入停车场时,检查停车场是否已满,如果未满则车辆进栈(车辆进入停车场);如果停车场已满,则车辆进入等候队列(车辆进入便道等候)。
②当车辆要求出栈时,该车到栈顶的那些车辆先弹出栈(在它之后进入的车辆必须先退出车场为它让路),再让该车出栈,其他车辆再按原次序进栈(进入车场)。
当车辆出栈完毕后,检查等候队列(便道)中是否有车,有车则从队列头取出一辆车压入栈中。
五、流程图六、详细设计1.本程序主要包含四个模块1) 主程序模块int main(){Initialization();CarNode car;SqStack Park,TempPark;LinkQueue Q;InitStack(Park);InitStack(TempPark);InitQueue(Q);while((scanf("%c%d%d",&car.event,&car.num,&car.time))&&(car.event!='e'&&car.event!='E')) {getchar(); //除去输入结束时的回车switch(car.event){case 'A':case 'a':Arrive(Park,Q,car);break;case 'D':case 'd':Leave(Park,TempPark,Q,car);break;default: printf("您的第一个数据输入有误!\n");break;}}printf("程序结束,谢谢使用!\n");return 0;2)分别构造空栈和空队列栈:Status InitStack(SqStack &S){ //构造一个空栈S.Stacksize=0;S.base=(CarNode*)malloc((MAX)*sizeof(CarNode));exit(OVERFLOW);printf("存储空间分配失败");}S.top=S.base;return OK;}队列:Status InitQueue(LinkQueue &Q){ //构造一个空队列(带头结点)Q.front=Q.rear=(QueueNode*)malloc(sizeof(QueueNode));if(!Q.front){exit(OVERFLOW);printf("存储空间分配失败");}Q.front->next=NULL;Q.queuesize=0;return OK;3)车辆到达处理Status Arrive(SqStack &S,LinkQueue &Q,CarNode &e){ //车辆到达处理if((S.top-1)->time<=e.time){ //时间处理if(!Check_Stack(S,e)&&!Check_Queue(Q,e)){ //是否已存在if(S.top-S.base<MAX){Push(S,e);printf("成功进入停车场,在%d号车库!\n",S.top-S.base);return OK;}else{EnQueue(Q,e);printf("停车场已满,车辆进入便道,在%d号车位!\n",Q.queuesize);}}printf("该牌照的车已存在,输入有误,请重新输入\n");return OK;}else{printf("时间输入有误,请重新输入!\n");return FALSE;}}4)车辆离开处理Status Leave(SqStack &S,SqStack &TempS,LinkQueue &Q,CarNode &e) { //车辆离开处理CarNode a;int leatime,leanum;int entertime; //进入停车场时间int cost;if(!(Check_Stack(S,e) || Check_Queue(Q,e))){printf("数据输入错误,本停车场内无所查询车辆,请重新输入!\n");return true;}else{if(Check_Stack(S,e)) //若需要离开的车辆在停车场{if(e.num==(S.top-1)->num) //车辆处在栈顶{Pop(S, a);leatime=e.time;leanum=e.num;entertime=a.time;printf("车辆进入车库时间:%d\t现在(离开)时间:%d\t停留时间:%d\t\n",entertime,leatime,leatime-entertime);}else //车辆处在栈中间{do{Pop(S,a); //从栈中依次退出Push(TempS,a); //依次进入临时栈}while((S.top-1)->num!=e.num);//直到top指针下一个位置的num=车牌号Pop(S, a); //该车离开leatime=e.time;leanum=e.num;entertime=a.time;printf("车进入停车场时间:%d\t现在(离开)时间:%d\t停留时间:%d\t\n",entertime,leatime,leatime-entertime);do { //其余车辆按原来次序返回停车场Pop(TempS,a);Push(S,a);}while(TempS.top!=TempS.base);//条件与上面不同,此时是全部回去}cost=(leatime-entertime)*price;if(cost>=0)printf("您的车牌号为%d 的车应交纳的费用是:%d\n",leanum,cost);if(Q.front!=Q.rear){ //队列不空的话从便道进停车场DeQueue(Q,a);if(a.time<leatime) //便道车辆进车库时间应该比车库车辆离开时间晚entertime=leatime;a.time=leatime;Push(S,a); //该车进入停车场printf("车牌号为%d的车辆从便道上进入%d号车库!从现在开始计时,现在时间为:%d\n",a.num,S.top-S.base,a.time);}}else if(Check_Queue(Q,e)){ //从便道直接离开do{DeQueue(Q,a);EnQueue(Q,a);}while(Q.front->next->data.num!=e.num);DeQueue(Q,e); //前面的车进入队尾printf("您的车牌号为%d 的车辆未进入车库从便道直接离开,费用为0!\n",e.num);}}return true;2.主要设计程序如下#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define MAX 2 //停车场容量#define price 2 //单价#define OK 1#define FALSE 0#define TRUE 1#define ERROR -1#define OVERFLOW -2typedef int Status;//===================================================================== typedef struct CarNode{int num;int time;}CarNode; //车辆信息结点typedef struct SqStack{CarNode *base;CarNode *top;int Stacksize;}SqStack; //栈(停车场)typedef struct QNode{CarNode data;struct QNode *next;}QueueNode; //便道结点typedef struct LinkQueue{QueueNode *front;QueueNode *rear;int queuesize;}LinkQueue; //队列(便道)//===================================================================== Status InitStack(SqStack &S){ //构造一个空栈S.Stacksize=0;S.base=(CarNode*)malloc((MAX)*sizeof(CarNode));if(!S.base){exit(OVERFLOW);printf("存储空间分配失败");}S.top=S.base;}//===================================================================== Status InitQueue(LinkQueue &Q){ //构造一个空队列(带头结点)Q.front=Q.rear=(QueueNode*)malloc(sizeof(QueueNode));if(!Q.front){exit(OVERFLOW);printf("存储空间分配失败");}Q.front->next=NULL;Q.queuesize=0;return OK;}//===================================================================== Status GetTop(SqStack S,CarNode &e){ //返回栈顶元素if(S.top==S.base)return ERROR;e=*(S.top-1);return TRUE;}//===================================================================== Status Pop(SqStack &S,CarNode &e){ //删除栈顶元素if(S.top==S.base)return ERROR;e=*--S.top;return OK;}//===================================================================== Status Push(SqStack &S,CarNode e){//插入元素为新的栈顶元素(在栈不满的前提下) if(S.top-S.base>=MAX)return FALSE;*S.top++=e;return OK;}//===================================================================== Status DeQueue(LinkQueue &Q,CarNode &e){ //删除队头元素(带头结点) if(Q.rear==Q.front)return ERROR;QueueNode *p=Q.front->next;e=p->data;Q.front->next=p->next;if(p==Q.rear)Q.rear=Q.front;free(p);Q.queuesize--;return OK;}//===================================================================== Status EnQueue(LinkQueue &Q,CarNode e){ //插入新的队尾元素QueueNode *p=(QueueNode*)malloc(sizeof(QueueNode));if(!p)exit(OVERFLOW);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;Q.queuesize++;return OK;}//=====================================================================Status Check_Stack(SqStack &S,CarNode e){//车辆到达时车库内是否有同名车CarNode *Temp=S.base;while((Temp!=(S.top))&&(Temp->num!=e.num))Temp++;if((Temp==S.top))return FALSE;elsereturn TRUE;}//===================================================================== Status Check_Queue(LinkQueue &Q,CarNode e){//车辆到达时便道上是否有同名车QueueNode *Temp=Q.front;while((Temp!=Q.rear) && (Temp->data.num!=e.num))Temp=Temp->next;if((Temp==Q.rear) && (Temp->data.num!=e.num))return FALSE;elsereturn TRUE;}//===================================================================== Status Arrive(SqStack &S,LinkQueue &Q,CarNode &e){ //车辆到达处理if((S.top-1)->time<=e.time){ //时间处理if(!Check_Stack(S,e)&&!Check_Queue(Q,e)){ //是否已存在if(S.top-S.base<MAX){Push(S,e);printf("成功进入停车场,在%d号车库!\n",S.top-S.base);return OK;}else{EnQueue(Q,e);printf("停车场已满,车辆进入便道,在%d号车位!\n",Q.queuesize);}}elseprintf("该牌照的车已存在,输入有误,请重新输入\n");return OK;}else{printf("时间输入有误,请重新输入!\n");return FALSE;}}//===================================================================== Status Leave(SqStack &S,SqStack &TempS,LinkQueue &Q,CarNode &e){ //车辆离开处理CarNode a;int leatime,leanum;int entertime; //进入停车场时间int cost;if(!(Check_Stack(S,e) || Check_Queue(Q,e))){printf("数据输入错误,本停车场内无所查询车辆,请重新输入!\n");return true;}else{if(Check_Stack(S,e)) //若需要离开的车辆在停车场{if(e.num==(S.top-1)->num) //车辆处在栈顶{Pop(S, a);leatime=e.time;leanum=e.num;entertime=a.time;printf("车辆进入车库时间:%d\t现在(离开)时间:%d\t停留时间:%d\t\n",entertime,leatime,leatime-entertime);}else //车辆处在栈中间{do{Pop(S,a); //从栈中依次退出Push(TempS,a); //依次进入临时栈}while((S.top-1)->num!=e.num);//直到top指针下一个位置的num=车牌号Pop(S, a); //该车离开leatime=e.time;leanum=e.num;entertime=a.time;printf("车进入停车场时间:%d\t现在(离开)时间:%d\t停留时间:%d\t\n",entertime,leatime,leatime-entertime);do { //其余车辆按原来次序返回停车场Pop(TempS,a);Push(S,a);}while(TempS.top!=TempS.base);//条件与上面不同,此时是全部回去}cost=(leatime-entertime)*price;if(cost>=0)printf("您的车牌号为%d 的车应交纳的费用是:%d\n",leanum,cost);if(Q.front!=Q.rear){ //队列不空的话从便道进停车场DeQueue(Q,a);if(a.time<leatime) //便道车辆进车库时间应该比车库车辆离开时间晚entertime=leatime;a.time=leatime;Push(S,a); //该车进入停车场printf("车牌号为%d的车辆从便道上进入%d号车库!从现在开始计时,现在时间为:%d\n",a.num,S.top-S.base,a.time);}}else if(Check_Queue(Q,e)){ //从便道直接离开do{DeQueue(Q,a);EnQueue(Q,a);}while(Q.front->next->data.num!=e.num);DeQueue(Q,e); //前面的车进入队尾printf("您的车牌号为%d 的车辆未进入车库从便道直接离开,费用为0!\n",e.num);}}return true;}//=====================================================================void Initialization(){ //初始化程序printf("姓名:杨智伟学号:2012040651\n");printf("==========================================================\n");printf("* 停车场管理模拟程序*\n");printf("==========================================================\n");printf("请依次输入车辆到达(A/a)/离去(D/d)/结束(E/e)信息、车牌号以及当前时间:\n\n");}//=====================================================================int main(){Initialization();CarNode car;SqStack Park,TempPark;LinkQueue Q;InitStack(Park);InitStack(TempPark);InitQueue(Q);while((scanf("%c%d%d",&car.event,&car.num,&car.time))&&(car.event!='e'&&car.event!='E')) {getchar(); //除去输入结束时的回车switch(car.event){case 'A':case 'a':Arrive(Park,Q,car);break;case 'D':case 'd':Leave(Park,TempPark,Q,car);break;default: printf("您的第一个数据输入有误!\n");break;}}printf("程序结束,谢谢使用!\n");return 0;}七、程序运行截图1.交互界面2.车辆进入3.车辆离去4.停车场已满进入便道5.便道车辆进入车库6.程序结束界面八、实验总结1.学会了栈和队列的综合使用,更加灵活运用栈和队列。
数据结构实验报告模拟停车场管理
数据结构实验报告模拟停车场管理实验目的:通过模拟停车场管理的过程,理解数据结构的应用和实际工程问题的解决思路。
实验内容:1.设计停车场类和车辆类,并实现相关操作方法。
2.模拟停车场管理的过程,包括车辆的进入和离开。
3.根据实际需求设计停车场管理算法,如何选择停车位和调度车辆等。
实验步骤:1.设计停车场类停车场类需要保存停车位的信息,可以使用数组或链表实现。
需要提供以下方法:- void addCar(Car car):将车辆添加到停车场,如果停车场已满,则禁止入场。
- void removeCar(Car car):将车辆从停车场移除,并更新停车位信息。
- int getAvailableSpaces(:返回停车场中当前可用的停车位数量。
2.设计车辆类车辆类需要保存车辆的信息,如车牌号、车型等。
3.实现停车场管理算法停车场管理需要考虑车辆进入和离开的顺序,以及停车位的选择等问题。
可以使用队列或堆栈等数据结构来保存车辆的进出顺序。
停车位的选择可以根据具体算法进行,如先到先得、最近最便等原则。
4.完成模拟停车场管理过程的代码根据实际需求,编写代码模拟车辆进入和离开停车场的过程。
可以通过输入车辆信息和操作指令来模拟。
5.测试与优化对停车场管理算法进行测试,并根据实际情况进行优化。
可以通过增加数据量、调整车辆进出顺序等方式进行测试,并根据测试结果进行优化。
实验结果:经过实验测试,停车场管理系统可以良好地处理车辆的进入和离开,并正确计算可用停车位的数量。
通过合理的停车位选择算法,确保了车辆进出的顺序。
实验总结:通过本次实验,我们学习了如何利用数据结构来实现停车场管理系统。
停车场管理系统是一种常见的实际应用,对于解决停车难问题具有重要意义。
在实验过程中,我们掌握了设计和实现停车场类、车辆类以及停车场管理算法的方法,加深了对数据结构的理解和应用。
在实验过程中,我们还发现停车场管理算法可以通过不同的策略进行优化,如最大化停车利用率、最小化顾客等待时间等。
数据结构-停车场管理程序代码
源程序代码:#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;}。
停车场管理程序实验报告
停车场管理程序实验报告一实验题目: 停车场管理程序二实验要求:编写一个程序实现停车场的管理功能。
并且,以栈模拟停车场,以队列模拟车场外到达便道的过程,按照从终端读入的输入数据序列进行模拟管理。
栈以顺序结构实现,队列顺序循环结构实现。
用户输入的命令有以下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辆小汽车的占地面积。
数据结构停车场实习报告
一、实习背景随着我国经济的快速发展,城市车辆数量逐年攀升,停车难问题日益突出。
为了解决这一问题,我们需要设计一个高效、便捷的停车场管理系统。
本次实习以数据结构为基础,设计并实现了一个停车场管理系统。
二、实习目的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. 数据结构应用:成功将栈和队列应用于停车场管理系统,提高了系统性能。
数据结构实验报告模拟停车场管理(含代码)
模拟停车场管理班级:物联网姓名: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{CarNode *stack[MAX+1];int top;}SeqStackCar;//狭道的堆栈顺序存储typedef struct car{CarNode *data;struct car *next;}QueueNode;//队列的链式存储typedef struct Node{QueueNode *head;QueueNode *rear;}LinkQueueCar;//便道上等候的队列定义2、主模块的流程及各子模块的主要功能○1车辆到达:int Arrival(SeqStackCar *Enter,LinkQueueCar *W)首先定义一个栈和队列的结构体指针为:*p , *t 。
然后申请一个车辆信息的内存空间,并把它赋给栈指针。
车辆到达时就输入车牌号,并通过if(Enter->top<MAX)来判断该车是进车场内还是进便道上,如果是进车场内就把top 加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)时结束。
- 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{CarNode *stack[MAX+1];int top;}SeqStackCar;//狭道的堆栈顺序存储typedef struct car{CarNode *data;struct car *next;}QueueNode;//队列的链式存储typedef struct Node{QueueNode *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{ // 定义时间结构体int hour;int min;}Time;typedef struct node{ // 定义车辆信息结构体char num[10];Time reach;Time leave;}CarNode;2、写出各模块的伪码算法void PRINT(CarNode *p,int room){ // 车辆收费int A1,A2,B1,B2;printf("\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)//进入便道或者狭道{CarNode *p;QueueNode *t;p=(CarNode *)malloc(sizeof(CarNode));flushall();printf("\n请输入车牌号(例:豫B1234):");gets(p->num);if(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);}else{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) { //车辆的离开int room;CarNode *p,*t;QueueNode *q;if(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");}else printf("\n车场里没有车.");}3、画出函数的调用关系图|---------------->到达函数-----||---------------->离开函数-------->停车费用主函数----------->显示车场里的情况|---------------->显示便道里的情况四、调试分析1、调试中遇到的问题及对问题的解决方法因为时间结构体里的小时,分钟都是用的是整型,所以如果出现1:01这个时间的话,会导致显示列表是1:1;这样的话会造成人的误解,同时会导致程序对停车缴纳的费用计算错误。
解决方法1:可以用数组和或者字符串来表示时间,但是问题来了,要是用字符串的话,算停车费有点问题,要废上一段时间的,会提高复杂度。
解决方案2:将输出用右对齐方式,缺位的用0补齐,这样最快捷啦!2、算法的时间复杂度和空间复杂度由于没有进行循环嵌套之类的运算,只有简单的循环语句,所以时间复杂度T(O)=O(n),在数据的存储方面,除了车牌号用的是数组以外,便道用的是顺序栈,这些是提前要申请一定的存储空间的,这样非动态分配的存储空间,在某些时候是会导致空间的浪费,增加其空间复杂度。