C语言停车场管理实验报告.pptx
数据结构用c语言实现停车场管理系统报告书
课程设计任务书学生姓名:专业班级:软件2101(计算2101)指导教师:黄启荃钱小红工作单位:华夏学院计算机教研室设计题目:用C语言实现停车场管理程序的设计初始条件:1、栈与队列的建立和操作.2、带T C或V C的计算机系统。
要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)主要任务:(在规定的时间内完成下列任务)设有一个停放n辆车的狭长停车场,它只有一个大门供车辆出入。
车辆按到达停车场时间的早晚依次从停车场最里面向大门处停放。
若已放满n辆车,则后来的车只能停在外面等待,当有车开走后方依次进入,停在场内的车按时计费。
编制一个程序模拟该停车场管理。
1.汽车的模拟输入信息格式可设为:汽车牌照号码,到达/离去时刻如(‘a’,1,5)为1号车在5时刻到达,(‘b’,5,20)为5号车在20这个时刻离去2. 要求程序输出每辆车到达后的停车位置,以及离开停车场时应缴纳的费用及停留时间。
3.编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果,并对采用的算法进行分析。
设计报告撰写格式要求:(课程设计报告按统一通用格式书写)具体内容如下:①设计任务与要求②总体方案与说明③程序主要模块的流程图④源程序清单与注释⑤问题分析与解决方案(包括调试记录、调试报告,即在调试过程中遇到的主要问题、解决方法及改进设想);⑥小结与体会附录:①源程序(必须有简单注释)②使用说明③参考资料时间安排:6月20日---24日第一天布置题目,确定任务、查找相关资料第二天~第四天功能分析,编写程序,调试程序、运行系统;第五天程序验收、答辩;撰写设计报告。
指导教师签字:2011年6月20日系主任签字:年月日设计题目:用C语言实现停车场管理程序的设计1、问题描述即要求停车场是一个可停放n辆汽车的狭长通道,并只有一个大门可供汽车进出,汽车在停车场内按车辆到达的先后顺序,依次由北向南排列(大门在最南端,最先到达的第一辆车停放在车场的最北端),如车长内已停满n辆汽车,则后来的汽车只能在门外的便道上等候,一旦有车开走,则排在便道上的第一辆车即可开入;当停车场内某辆车要离开时,在它后进入的车辆必须先退出车场为它让路,待该辆车开出大门外,其它车辆再按原次序进入车场,每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用,以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入的输入数据序列进行模拟管理.每一组输入数据包括三个数据项:汽车”到达”或”离去”信息,汽车牌照号码以及到达或离去的时刻(到达或离去的时刻也可用计算机控制).对每一组输入数据进行操作后的输入信息为:如是车辆到达,则输入汽车在停车场内或便道上的停留位置;如是车辆离去,则输入汽车在停车场内停留的时间和应交的费用。
C++数据结构停车场管理
数据结构实验报告实验题目:停车场管理学生姓名:班级:学号:问题描述设有一个停车场,它是利用一个南北向的狭窄通道建成,北端封闭,大门在最南端。
最先到达的汽车停放在最北端,后面到达的汽车从北至南依次顺序停放。
停车场只能停放n 辆汽车。
当停车场停满n辆车后,后面到达的汽车只能在门外的便道上等候。
一旦有汽车开走,便道上等候的第一辆车就可以开入停车场停放。
当停车场内某辆汽车要离开时,在它之后进入的车辆必须先退出停车场为它让路,待该车开出大门外,其他汽车再按原次序返回车场。
每辆停放在车场内的汽车在离开时必须按它停放时间的长短交纳费用。
例题分析每到达一辆汽车,先检查停车场栈是否已满,若未满则该车进入停车场停放(入栈操作),并将该车的车号和停放时刻记录在停车场栈的相应元素中,同时显示该车在停车场内的停放位置。
反之,若停车场已满,则该车排到便道上等候的汽车队列最后(入队列操作),并将该车的车号信息记录在汽车队列的相应结点内,同时显示该车在便道上的停放位置。
若要取一辆汽车,则需依次进行下述操作:将阻挡在它后面的汽车退出(停车场栈的出栈操作),并将这些汽车临时存放在另一个辅助栈中(辅助栈的入栈操作);开走要取的汽车(停车场栈的出栈操作),并显示该车应交纳的费用;依次从辅助栈中开出汽车(辅助栈出栈操作),开回停车场中(停车场栈的入栈操作);这时停车场已有一个空车位,便道上等候的第一辆汽车则可以开进停车场内停放(汽车队列的出队列操作和停车场栈的入栈操作)。
程序源代码#include<iostream>#include<conio.h>#include<iomanip>#include<fstream>#include<string>#include <stdlib.h>#include <windows.h>using namespace std;#define Max_Size 2//停车的最大容量#define HourFare 2 //每小时的停车费用int CountForStack=0; //栈里现有的车数int CountForQueue=0; //排队等候的车数typedef struct{char Condition;//到达或者离开的状态int Arrivetime;//到达时间,默认为-1,表示没有到达int Leavetime;//离开时间,默认为-1,表示没有离开int License;//车牌号}CarNode;//保存每辆车的信息typedef struct//栈的定义{CarNode *base;//栈底指针CarNode *top;//栈顶指针int Stacksize;//栈的最大容量}CarStack;typedef struct QNode{char Condition;//到达或者离开的状态int Arrivetime;//到达时间,默认为-1,表示没有到达int Leavetime;//离开时间,默认为-1,表示没有离开int License;//车牌号QNode *next;}QNode;typedef struct//队列的定义QNode *front;//对头指针QNode * rear;//队尾指针}Queue;bool InitStack(CarStack &S1)//初始化栈S1{S1.base=(CarNode*)malloc(Max_Size*sizeof(CarNode));if(!S1.base){cout<<"栈S1 内存分配失败"<<endl;return false;}S1.top=S1.base;S1.Stacksize=Max_Size;return true;}bool InitQueue(Queue &Q){Q.front=(QNode*)malloc(sizeof(QNode));if(!Q.front){cout<<"队列Q 内存分配失败!"<<endl;return false;}Q.rear=Q.front;Q.front->next=NULL;return true;}bool EnQueue(Queue &Q,QNode &e)//插入元素e 为Q 的新的队尾元素QNode *p=(QNode *)malloc(sizeof(QNode));if(!p){cout<<"p 内存分配失败"<<endl;return false;}p->Arrivetime=e.Arrivetime;p->Leavetime=e.Leavetime;p->Condition=e.Condition;p->License=e.License;//将e 赋给Pp->next=NULL;Q.rear->next=p;Q.rear=p;return true;}bool DeQueue(Queue &Q,QNode &t)//出队列函数{if(Q.front==Q.rear){cout<<"队列为空!"<<endl;return false;}QNode *p=Q.front->next;t.Arrivetime=p->Arrivetime;t.Condition=p->Condition;t.Leavetime=p->Leavetime;t.License=p->License;Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;}free(p);return true;}void InitCarNode(CarNode &C,char condition,int arrivetime,int leavetime,int license) {C.Arrivetime=arrivetime;C.Condition=condition;C.Leavetime=leavetime;C.License=license;}bool Push(CarStack &S1,CarNode &car)//插入新的元素car 为的栈顶元素{if(S1.top-S1.base>=S1.Stacksize){cout<<"此栈已满,不能压入新的信息"<<endl;return false;}(*S1.top).Arrivetime=car.Arrivetime;(*S1.top).Condition=car.Condition;(*S1.top).Leavetime=car.Leavetime;(*S1.top).License=car.License;++S1.top;//栈顶指针上移return true;}bool Pop(CarStack &S1,CarNode &t)//出栈操作{if(S1.top==S1.base)cout<<"栈S1 为空,不能执行出栈操作"<<endl;return false;}--S1.top;//栈顶指针下移t.Arrivetime=(*S1.top).Arrivetime;t.Condition=(*S1.top).Condition;t.Leavetime=(*S1.top).Leavetime;t.License=(*S1.top).License;return true;}bool IsStackFull(CarStack &S1)//判断S1 栈是否已满{if(S1.top-S1.base>=S1.Stacksize)return true;elsereturn false;}bool IsStackEmpty(CarStack &S1)//判断S1 栈是否已空{if(S1.top==S1.base)return true;elsereturn false;}bool IsQueueEmpty(Queue &Q)//判断队列是否为空{if(Q.front==Q.rear)return true;elsereturn false;}bool SearchInStack(CarStack &S1,int a)//a 表示要查找的车牌号,如果在停车场里面,就返回true{bool tag=false;if(!IsStackEmpty(S1))//如果栈S1 非空{CarNode *p=S1.top-1;while(p!=S1.base){if((*p).License==a)tag=true;--p;}if((*p).License==a)tag=true;}return tag;}bool SearchInQueue(Queue &Q,int a)//a 表示要查找的车牌号,如果在通道里面,就返回true{bool tag=false;if(!IsQueueEmpty(Q))//如果队列非空{QNode *p=Q.front->next;while(p!=Q.rear){if((*p).License ==a)tag=true;p=p->next;}//退出此while 循环时p 指向最后一个元素if((*p).License ==a)tag=true;}return tag;}void InCar(CarStack &S1,Queue &Q,int a1,int a2)//表示进入车辆,a1 表示到达时间,a2 表示车牌号码{if(SearchInStack(S1,a2)){cout<<"车号"<<a2<<"已经存在于停车场内,输入有误"<<endl;return;}if(SearchInQueue(Q,a2)){cout<<"车号"<<a2<<"已经存在于通道内,输入有误"<<endl;return;}if(IsStackFull(S1))//如果堆栈已满,说明停车场已满,需要停车在通道里面{QNode qnode;qnode.Arrivetime=-1;//在通道里面不收费,所以不计时qnode.Condition='A';qnode.Leavetime=-1;//定义为-1,说明还没有开始离开qnode.License=a2;EnQueue(Q,qnode);//停在通道上++CountForQueue;cout<<"车号:"<<qnode.License<<"停在通道的第"<<CountForQueue<<"号位置"<<endl;}else{CarNode carnode;carnode.Arrivetime=a1;carnode.Condition='A';carnode.Leavetime=-1;carnode.License=a2;Push(S1,carnode);++CountForStack;cout<<"车号:"<<carnode.License<<",到达时间:"<<carnode.Arrivetime<<" 点,停在停车场的第"<<CountForStack<<"号位置"<<endl;}}void Sreach(CarStack &S1,Queue &Q,int a){if(SearchInStack(S1,a)){cout<<"车号:"<<a<<"已存在停车场里面的第"<<CountForStack<<"号位置"<<endl;return;}if(SearchInQueue(Q,a)){cout<<"停车场已满,车号"<<a<<"存在于通道里面的第"<<CountForQueue<<"号位置,在次等候"<<endl;return;}else{cout<<"对不起!你查找的车号不在停车场里面"<<endl;return;}}void OutCar(CarStack &S1,Queue &Q,int a1,int a2)//出车函数,a1 表示离开时间,a2 表示车牌号码{if(SearchInQueue(Q,a2)){cout<<"车号"<<a2<<"存在于通道里面,还没有进入停车场,不能离开"<<endl;return;}if(!SearchInStack(S1,a2)){cout<<"车号"<<a2<<"该车不在停车场内"<<endl;return;}CarStack tempstack;InitStack(tempstack);//新建一个栈,存放让路的汽车bool tag1=false;//标志这个停车场出车以前是否已满,默认为没有满tag1=IsStackFull(S1);bool tag2=true;//标志通道是否有汽车在等待,默认为通道为空tag2=IsQueueEmpty(Q); CarNode temp;//用来保存暂时取出的汽车bool tag3=false;while(1){Pop(S1,temp);if(temp.License==a2){if(a1<temp.Arrivetime){cout<<"离开失败!"<<endl;tag3=true;Push(tempstack,temp);}else{cout<<"车号:"<<a2<<"现在离开停车场,所用时间为:"<<a1-temp.Arrivetime<<"小时,应收RMB 为:"<<(a1-temp.Arrivetime)*HourFare<<"元"<<endl;}break;}elsePush(tempstack,temp);//进入暂存栈} 则把前面倒出的车再次放while(!IsStackEmpty(tempstack))//如果临时栈不空,入停车场{Pop(tempstack,temp);Push(S1,temp);}QNode tempqnode;//用来暂时保存从通道出来的汽车if(tag1==true&&tag2==false&&tag3==false)//如果出车前停车场已满,并且通道不为空,并且离开没有失败{DeQueue(Q,tempqnode);--CountForQueue;temp.Arrivetime=a1;temp.Condition=tempqnode.Condition;temp.Leavetime=tempqnode.Leavetime;temp.License=tempqnode.License;Push(S1,temp);}if(tag3==false)//如果停车通道是空的,停车场没有满,并且离开成功{--CountForStack;}}}void showmenu(CarStack &S1,Queue &Q){cout<<"******************************选择菜单*******************************"<<endl;cout<<" 1: 停车"<<endl;cout<<" 2: 离开停车场"<<endl;cout<<" 3: 查看车辆信息"<<endl;cout<<" 4: 退出系统"<<endl;cout<<"*****************************请按键选择******************************"<<endl;int tag;cin>>tag;while(tag!=1&&tag!=2&&tag!=3&&tag!=4)cin>>tag;int a1;unsigned int a2;switch(tag){case 1:cout<<"请输入到达的车号:"<<endl;cin>>a1;cout<<"请输入到达的时间:"<<endl;cin>>a2;InCar(S1,Q,a2,a1);Sreach(S1,Q,a1);break;case 2:cout<<"请输入离开的车号:"<<endl; cin>>a1;cout<<"请输入离开的时间:"<<endl; cin>>a2;OutCar(S1,Q,a2,a1);break;case 3:cout<<"请输入你要查看的车号:"<<endl;cin>>a1;Sreach(S1,Q,a1);break;case 4:return;break;}showmenu(S1,Q);}void main(){CarStack carstack;InitStack(carstack);//建立并且初始化用于停车场的堆栈Queue carQueue;InitQueue(carQueue);//建立并且初始化用于通道的队列showmenu(carstack,carQueue);}。
C语言 停车场管理系统
附件二【学生用】西北农林科技大学信息工程学院数据结构实习报告题目:停车场管理系统学号2011013200姓名阮屹专业班级电子商务111指导教师戴涛、杨会君实践日期2012-7-6至2012-7-15目录一、综合训练目的与要求 (1)二、综合训练任务 (1)三、总体设计 (1)四、详细设计说明 (1)五、调试与测试 (7)六、实习日志 (13)七、实习总结 (13)八、附录:核心代码清单 (14)一、综合训练目的与要求正文综合训练的目的本综合训练是计算机科学与技术、信息管理与信息系统、软件工程专业重要的实践性环节之一,是在学生学习完《程序设计语言(C)》、《数据结构》课程后进行的一次全面的综合练习。
本课综合训练的目的和任务:1. 巩固和加深学生对C语言、数据结构课程的基本知识的理解和掌握2. 掌握C语言编程和程序调试的基本技能3. 利用C语言进行基本的软件设计4. 掌握书写程序设计说明文档的能力5. 提高运用C语言、数据结构解决实际问题的能力综合训练要求1. 分析综合训练题目的要求2. 写出详细设计说明3. 编写程序代码,调试程序使其能正确运行4. 设计完成的软件要便于操作和使用4. 设计完成后提交课程设计报告二、综合训练任务通过此系统可以实现如下功能:若是车辆到达,则输入汽车在停车场内或便道上的停车位置以及进站时间,当车子出站时,则显示在停车场内停车时间,并;应当支付的金额要求:设计合理的存储结构,设计界面,设计程序完成功能;三、总体设计该程序是模拟了一个特殊车站,车站是一条直线,只有一个入口,车子要出站则他前边的车子都要为其让路,然后再回来并且覆盖出站车子原来的位置,这明显是一个要用到栈的环境。
而当车站满了之后,便在一旁的便道里排队等待,先排队的当然先进车站。
这是原题,我做了些许改动,设计了会员系统,会员享受9折优惠并且有会员专用便道,在车站满的情况下优先进入车站。
四、详细设计说明整体设计如上,那么现在详细分析程序。
数据结构(C语言版)停车场管理(完美版)
数据结构(C语言版)停车场管理(完美版)#include#include#include#define OK 1#define OVERFLOW -2#define SIZE 2 //停车场位置数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(OVERFLOW);P.top=P.base;P.stacksize=0;return OK;}Status Push(Park &P,CarNode e){ //车进入停车场*P.top++=e;++P.stacksize;return OK;}Status Pop(Park &P,CarNode &e){ //车离开停车场if(P.top==P.base)printf("停车场为空");else{e=*--P.top;--P.stacksize;}return OK;}Status InitQueue(Shortcut &S){ //初始化便道S.front=S.rear=(CarPtr)malloc(sizeof(Car2));if(!S.front||!S.rear)exit(OVERFLOW);S.front->next=NULL;S.length=0;return OK;}Status EnQueue(Shortcut &S,int number,int ar_time){ //车进入便道CarPtr p;p=(CarPtr)malloc(sizeof(Car2));if(!p)exit(OVERFLOW);p->number=number;p->ar_time=ar_time;p->next=NULL;S.rear->next=p;S.rear=p;++S.length;return OK;}Status DeQueue(Shortcut &S,CarPtr &w){ //车离开便道if(S.length==0)printf("通道为空");else{w=S.front->next;S.front->next=w->next;--S.length;}return OK;}//对进栈车辆的处理Status Arrival(Park &P,Shortcut &S){int number,ar_time;printf("请输入车牌号:");scanf("%d",&number);printf("请输入进停车场的时刻:");scanf("%d",&ar_time);if(P.stacksize<size){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个位置。
C语言程序设计实习报告-停车场管理系统
C语言课程设计实习报告姓名:成帅安学号:20141002605院(系):工程学院专业:土木工程2016年6 月2016.6 中国地质大学C语言课程设计 1 第一章停车场管理系统§1.1题目描述1、有一个两层的停车场,每层有6个车位,当第一层车停满后才允许使用第二层,(停车场可用一个二维数组实现,每个数组元素存放一个车牌号)每辆车的信息包括车牌号,层号,车位号,停车时间共4项,其中停车时间按分钟计算。
2、假设停车场初始状态为第一层已经停有4辆车,其车位号依次为1-4,停车时间依次为20,15,10,5。
即先将这四辆车的信息存入文件“car.dat"中(数组的对应元素也要进行赋值)。
3、停车操作:当一辆车进入停车场时,先输入其车牌号,再为它分配一个层号和一个车位号(分配前先查询车位的使用情况,如果第一层有空则必须停在第一层),停车时间设为5,最后将新停入的汽车的信息添加文件"car.dat"中,并将在此之前的所有车的停车时间加5。
4、收费管理(取车):当有车离开时,输入其车牌号,先按其停车时间计算费用,每5分钟0.2元。
(停车费用可设置一个变量进行保存),同时从文件"car.dat"中删除该车的信息,并将该车对应的车位设置为可使用状态(即二维数组对应元素清零)。
按用户的选择来判断是否要输出停车收费的总计。
5、输出停车场中全部车辆的信息。
6、退出系统。
§1.2算法设计1、需求分析:车辆信息用文件储存,提供文件的输入输出操作;当车离开时要删除文件中该车的信息,因而要提供文件的删除操作;用键盘式菜单实现功能选择。
2、总体设计思路:整个管理系统设计可设计为停车模块、取车模块、车辆浏览信息模块。
另外车辆停放信息涉及到从car.dat中读取,保存和修改,为了方便起见和程序的模块化,我将文件的读入和保存单独设计为两个子程序。
整体模块图如下:23、各子程序设计如下:(1)使用全局变量数组,用一个二维数组实现停车场车位的信息,int cars[12][4];2016.6 中国地质大学C语言课程设计 3 (2)通过读取car.dat的数据,对程序初始化。
数据结构停车场管理实验报告
数据结构停车场管理实验报告一、实验目的本次实验旨在通过设计和实现一个停车场管理系统,深入理解和应用数据结构中的栈和队列等知识,提高解决实际问题的能力。
二、实验环境编程语言: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、车辆正常进入停车场,并在停车场已满时在便道等待。
数据结构-停车场管理系统实验报告
数据结构-停车场管理系统实验报告数据结构停车场管理系统实验报告一、实验目的本次实验旨在通过设计和实现一个停车场管理系统,深入理解和应用数据结构的知识,包括栈、队列、链表等,提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为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 <<"停车场内没有车辆。
C语言课程设计停车场管理
感谢您的观看
汇报人:
校等。
停车场管理系统的功能
车辆识别:自动识别车牌号码,记录车辆信息 车位管理:实时更新车位使用情况,显示剩余车位数量 收费管理:自动计算停车费用,支持多种支付方式 车辆引导:提供车辆引导服务,帮助车主快速找到空闲车位 安全监控:实时监控停车场内车辆和人员活动,保障停车场安全 数据分析:统计停车场使用情况,为停车场管理提供决策支持
错误处理:使用if、else、switch等语句进行错误处理,如处理输场管理系统中的优势
易于理解和学习:C语言语法简单,易于理解和学习,适合初学者使用。
强大的功能:C语言具有强大的功能,可以处理复杂的数据结构和算法,适合停车场管理系统 的需求。
高效的运行速度:C语言编译后的程序运行速度快,适合停车场管理系统对实时性的要求。
和性能。
停车场管理系统优化与改进
优化算法:提高系统运行效率,降低资源消耗 增加功能:如车位预约、停车引导、停车支付等 提高安全性:加强数据加密,防止数据泄露 优化用户体验:简化操作流程,提高用户满意度
06
停车场管理系统应用与 维护
停车场管理系统的部署与安装
硬件需求:服务器、网络设备、监控设备等 软件需求:停车场管理系统软件、数据库管理系统等 安装步骤:硬件安装、软件安装、系统调试等 维护与更新:定期检查硬件设备、软件更新、数据备份等
可移植性:C语言具有良好的可移植性,可以在不同的操作系统和硬件平台上运行,适合停车 场管理系统在不同环境下的运行需求。
04 停车场管理系统设计
停车场管理系统需求分析
停车场管理系统C语言实习报告
停车场管理系统C语言实习报告一、实习背景在城市化进程不断加速的背景下,汽车数量急剧增长,停车难的问题日益突出,停车场管理系统成为解决这一问题的重要途径。
为了更好地了解和掌握停车场管理系统的开发过程和实现方法,我选择了该方向作为我的实习内容。
二、实习过程在实习过程中,我主要参与了停车场管理系统的需求分析、模块设计和编码实现等工作。
1.需求分析首先,我对停车场管理系统的需求进行了详细地分析和理解。
通过与公司内部相关人员的交流和讨论,我了解到停车场管理系统主要包括车辆信息管理、停车记录管理和收费管理等功能。
2.模块设计在需求分析的基础上,我开始进行停车场管理系统的模块设计工作。
根据需求,我划分出了车辆信息管理模块、停车记录管理模块和收费管理模块等多个模块。
然后,我详细地设计了这些模块的功能和数据流程,并与其他开发人员进行了交流和讨论。
3.编码实现在模块设计完成后,我开始进行停车场管理系统的编码实现工作。
首先,我选择了C语言作为开发语言,并使用了相关的开发工具。
然后,我按照设计的流程和规范进行了编码工作,并通过反复调试和测试,最终实现了一个具有基本功能的停车场管理系统。
三、实习收获通过这次实习,我对停车场管理系统的开发和实现过程有了更深入的了解和掌握。
首先,我学会了如何进行需求分析和模块设计,并将其应用于实际开发中。
其次,我通过实际编码实现了停车场管理系统,并通过调试和测试不断完善和优化。
最后,我还与其他开发人员进行了紧密的合作和协调,提高了我与他人沟通和协作的能力。
四、总结与展望通过这次实习,我对停车场管理系统有了全面的认识和了解,并学会了如何进行开发和实现。
但是,在实际工作中还存在一些不足之处,比如对一些技术的了解不够深入和对一些问题的解决不够完善。
因此,我希望今后能够进一步加强相关技术的学习和研究,提高自己的综合能力和解决问题的能力。
在未来的工作中,我将继续深入研究和学习停车场管理系统的相关技术,并通过不断地实践和探索,提高自己的专业能力和水平。
C语言实现简易停车场管理系统
C 语⾔实现简易停车场管理系统本⽂实例为⼤家分享了C 语⾔实现停车场管理系统的具体代码,供⼤家参考,具体内容如下问题描述:设停车场内只有⼀个可停放n 辆汽车的狭长通道,且只有⼀个⼤门可供汽车进出。
汽车在停车场内按车辆到达时间的先后顺序,依次由北向南排列(⼤门在最南端,最先到达的第⼀辆车停放在车场的最北端),若车场内已停满n 辆汽车,则后来的汽车只能在门外的便道上等候,⼀旦有车开⾛,则排在便道上的第⼀辆车即可开⼊;当停车场内某辆车要离开时,在它之后开⼊的车辆必须先退出车场为它让路,待该辆车开出⼤门外,其它车辆再按原次序进⼊车场,每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费⽤。
由题得,此系统要实现的功能为:(1)设计停车场内的结构。
(由题分析为⼀个栈,因为只有⼀个门所以其就像数据结构中学到的栈,但是因为既要出栈⼜要⼊栈,此处我就将这个栈简化为了⼀个链表)(2)当车库满时,在车库外等待的结构。
(就像排队⼀样,先来先进后来后进,只能从⼀端进,另⼀端出)。
(3)车辆的结构,⼀辆车要有什么信息?⾸先要有这辆车的车牌号,可以⽤⼀个字符数组来存储(因为车牌不⼀定全是数字,还可能有汉字,英⽂字母等),题中要求要⽤要计算收费,就要知道驶⼊时间和驶出时间(怎样获取在下⾯会说到)。
算法描述:1、刚开始定义结构类型,如车的类型,车库⾥的类型,车库外等待的类型。
2、声明所要⽤到的函数:1234567891011121314void menu(Stack *cheku,SequenQueue* paidui);//开始菜单 //就是展⽰出菜单的函数//队列的相关操作SequenQueue* InitQueue();//申请⼀个空队int EmptyQueue(SequenQueue* Q);//判断队空int FullQueue(SequenQueue* Q);//判断队满int EnQueue(SequenQueue* Q, ElemType *e);//⼊队int DeQueue(SequenQueue* Q, ElemType *e); //出队Stack* build();//建链表int fullstack(Stack *cheku);//判断链表满void tingche(Stack *cheku,SequenQueue* paidui);//停车的函数void likai(Stack *cheku,SequenQueue* paidui);//离开的函数void chakan(Stack *cheku,SequenQueue* paidui);//查看车库停车情况的函数3、⼀些可能不理解的说明的说明。
停车场管理系统C语言实现
一.问题描述1.实验题目:设停车场是一个可停放n 辆汽车的狭长通道,且只有一个大门可供汽车进出;汽车在停车场内按车辆到达时间的先后顺序,依次由北向南排列大门在最南端,最先到达的第一辆车停放在车场的最北端;若停车场内已经停满n辆车,那么后来的车只能在门外的便道上等候;一旦有车开走,则排在便道上的第一辆车即可开入;当停车场内某辆车要离开时,在它之后进入的车辆必须先退出车场为它让路,待该辆车开出大门外,其他车辆再按原次序进入车场;每辆停放在车场的车在它离开停车场时必须按它停留的时间长短缴纳费用;试为停车场编制按上述要求进行管理的模拟程序;要求:根据各结点的信息,调用相应的函数或者语句,将结点入栈入队,出栈或者出队;二.需求分析1.程序所能达到的基本可能:程序以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入数据的序列进行模拟管理;栈以顺序结构实现,队列以链表结构实现;同时另设一个栈,临时停放为给要离去的汽车让路而从停车场退出来的汽车;输入数据按到达或离去的时刻有序;当输入数据包括数据项为汽车的“到达”‘A’表示信息,汽车标识牌照号以及到达时刻时,应输出汽车在停车场内或者便道上的停车位置;当输入数据包括数据项为汽车的“离去”‘D’表示信息,汽车标识牌照号以及离去时刻时,应输出汽车在停车场停留的时间和应缴纳的费用便道上停留的时间不收费;当输入数据项为‘P’,0,0时,应输出停车场的车数;当输入数据项为‘W’, 0, 0时,应输出候车场车数;当输入数据项为‘E’, 0, 0,退出程序;若输入数据项不是以上所述,就输出"ERROR";2.输入输出形式及输入值范围:程序运行后进入循环,显示提示信息:“Please input the state,number and time of the car:”,提示用户输入车辆信息“到达”或者“离开”,车牌编号,到达或者离开的时间;若车辆信息为“到达”,车辆信息开始进栈模拟停车场,当栈满,会显示栈满信息:“The parking place is full”,同时车辆进队列模拟停车场旁便道,并显示该进入便道车辆的车牌编号,让用户知道该车的具体位置;若车辆信息为“离开”,会显示该车进入停车场的时间以及相应的停车费用,若该车较部分车早进停车场,这部分车需先退出停车场,暂时进入一个新栈为其让道,会显示进入新栈的车辆的车牌编号及其入停车场的时间,当待离开车离开停车场后,这部分车会重新进入停车场,同时便道上的第一辆车进入停车场;若输入‘P ’,0,0,会显示停车场的车数;若输入‘W ’,0,0,会显示便道上的车数;若输入‘E ’,0,0,程序会跳出循环,同时程序结束;若输入为其他字母,程序会显示“ERROR ”报错;若便道上没有车辆停靠,会显示便道为空的信息:用户每输入一组数据,程序就会根据相应输入给出输出;输入值第一个必须为字母,后两个为数字;3.测试数据要求:用户输入字母时,输入大写或小写,都可以被该程序识别,正常运行;但要求用户输入数据时,三个数据项之间必须用逗号相分隔开;三.概要设计为了实现上述功能,该程序以栈模拟停车场以及临时停放为给要离去的汽车让路而从停车场退出来的汽车的场地,以队列模拟车场外的便道,因此需要栈和队列这两个抽象数据类型;1.栈抽象数据类型定义:ADT SqStack{数据对象:D={char d c b a d c b a i i i i i i i i ∈∈∈∈int,int,int,|,,,, i=1,2,3....,n,n 0≥}数据关系:R={i i i d b a ,,|∈i i i d b a ,,D,∈i i i d b a ,,struct car};基本操作:Judge_Outputs,q,r ;列抽象数据类型定义:ADT LinkQueue{数据对象:D={∈i i i i a c b a |,,Qnode ,∈i b Qnode,int ∈i c ,i=1,2,3....,n,n 0≥};数据关系:R=φ;基本操作:Judge_Outputs,q,r;要算法流程图:I.Judge_Output算法流程图:II.A_cars算法流程图:III.D_cars算法流程图:4.本程序保护模块:主函数模块栈单元模块:实现栈的抽象数据类型队列单元模块:实现队列的抽象数据类型调用关系:四.详细设计1.相关头文件库的调用说明:include<>include<>define MAXSIZE 14define n 2define fee 102.元素类型、结点类型和结点指针类型:struct car{ char bb;int num;int time;};struct rangweicar{int num;int time;};typedef struct stackk{struct rangweicar HMAXSIZE;int topp;}SqStackk;define QNODE struct QnodeQNODE { int data;QNODE next;};3.栈类型和队列类型:typedef struct stack{struct car Gn;int top;}SqStack;typedef struct linkqueue{QNODE front,rear;int geshu;}LinkQueue;b=='E'||r.bb=='e'printf"STOP\n";else ifr.bb=='P'||r.bb=='p'printf"The number of parking cars is %d\n",s->top+1; else ifr.bb=='W'||r.bb=='w'printf"The number of waiting cars is %d\n",q->geshu; else ifr.bb=='A'||r.bb=='a'A_carss,q,r;else ifr.bb=='D'||r.bb=='d'D_carss,q,r;elseprintf"ERROR\n";}A_carsSqStack s,LinkQueue q,struct car a {QNODE t;ifs->top=n-1{s->top++;s->Gs->top.bb=;s->Gs->top.num=;s->Gs->top.time=;}else{printf"The parking place is full\n";t=QNODE mallocsizeofQNODE;t->data=;t->next=NULL;q->rear->next=t;q->rear=t;printf"the number of the car in the access road is:%d\n",q->rear->data;q->geshu++;}}int D_carsSqStack s,LinkQueue q,struct car d{int i,j,l;float x,y;QNODE p;SqStackk k;if==s->Gs->top.num{x=s->Gs->top.time;y=feex;printf"The time is %.2f hours,the fee is %.2f yuan\n",x,y;ifq->geshu==0{printf"The queue is empty\n";return 0;}else{p=q->front->next;q->front->next=p->next;s->Gs->top.num=p->data;s->Gs->top.time=;freep;q->geshu--;ifq->front->next==NULLq->rear=q->front;return 1;}}else{fori=0;i<s->top;i++{ifs->Gi.num= continue;else break;}ifi>=s->top{printf"ERROR\n";return -1;}x=s->Gi.time;y=feex;printf"The time is %.2f hours,the fee is %.2f yuan\n",x,y; k=SqStackk mallocsizeofSqStackk;k->topp=-1;forj=s->top;j>i;j--{k->topp++; k->Hk->topp.num=s->Gj.num;k->Hk->topp.time=s->Gj.time;s->top--;}forl=0;l<=k->topp;l++{printf"the informationnumber and time in the new stack is:\n"; printf"%d,%d\n",k->Hl.num,k->Hl.time;}s->top--;whilek->topp>=0{s->top++;s->Gs->top.bb='A';s->Gs->top.num=k->Hk->topp.num;s->Gs->top.time=k->Hk->topp.time;k->topp--;}ifq->geshu==0{printf"The access road is empty\n";return 2;}else{s->top++;p=q->front->next;q->front->next=p->next;s->Gs->top.num=p->data;s->Gs->top.time=;freep;q->geshu--;ifq->front->next==NULLq->rear=q->front;return 3;}}}4.主函数的伪码:main{SqStack s;LinkQueue q;QNODE p;struct car aaMAXSIZE;int i;s=SqStack mallocsizeofSqStack;s->top=-1;q=LinkQueue mallocsizeofLinkQueue;p=QNODE mallocsizeofQNODE;p->next=NULL;q->front=q->rear=p;q->geshu=0;printf"\n";printf" \n";printf" 停车场管理系统\n";printf" \n";printf"\n";fori=0;i<MAXSIZE;i++{printf"Please input the state,number and time of the car:\n";scanf"%c,%d,%d",&aai.bb,&aai.num,&aai.time;getchar;Judge_Outputs,q,&aai;ifaai.bb=='E'||aai.bb=='e' break;}}5.函数调用关系:五.测试分析:1.出现问题及解决办法:该程序是四个程序调试中最顺利的一个,只在一个地方上出了问题,就是输入字符时由于回车键也是字符,回车键总会被读入,导致经常输出“ERROR”;后来找到原因后在scanf函数后紧接着加了一个getchar;语句后就恢复了正常;2.方法优缺点分析:优点:用栈和队列来模拟停车场让整个问题显得简单,易于实现;缺点:栈和队列这两个数学模型用在停车场管理上还是有失妥当的,现实中停车场出口入口不可能为同一处,不可能当一辆车要离开,在它后面进来的车必须为它让路,因此无法用栈的“后进先出”原则来模拟;而且没有考虑便道上的车在等待过程中可以中途开走等情况,而这些都无法用队列的“先进先出”原则来模拟;3.主要算法的时间和空间复杂度分析:1由于算法Judge_Output函数根据判断条件,每次只选择一个程序段执行,所以其时间复杂度是O1;2由于算法A_cars函数根据判断条件,将数据入栈或入队列,所以其时间复杂度也是O1;3由于算法D_cars函数在出栈数据不在最顶端时需将n个数据先出该栈,再入新栈,再回旧栈的操作,故其时间复杂度是On;4所有算法的空间复杂度都是O1;六.使用说明程序运行后用户根据提示一次输入车辆的状态信息,车牌编号,时间,程序会根据车辆的状态信息调用相应的函数,并输出用户想得到的信息;七.调试结果输入数据:‘A’,1,5,‘A’,2,10,‘D’,1,15,‘A’,3, 20,‘A’,4,25,‘A’,5,30,‘D’,2,35,‘D’,4,40,‘P’,0,0,‘W’,0,0,‘F’,0,0,‘E’,0,0;输出数据:1号车停放时间为10小时,收费100元;2号车停放时间为25小时,收费250元;4号车停放5小时,收费50元;此时停车场有两辆车,便道上无车;若停车场已满,则会显示停车场已满的信息;若便道上无车等待停车,会显示便道上无车的信息;若中途有车离开,需其后的车让道,会显示进入临时停车场的车辆的信息;若输入‘F’,0,0,输出“ERROR”;若输入‘E’,0,0,程序结束;运行结果截屏:八.附录源程序文件清单:include<> /调用的头文件库声明/include<>define MAXSIZE 14define n 2define fee 10struct car /用该结构体来存放车的状态,编号和时间信息/ { char bb;int num;int time;};typedef struct stack /用该栈来模拟停车场/{struct car Gn;int top;}SqStack;struct rangweicar /用该结构体来存放临时让出的车辆的编号以及时间信息/ {int num;int time;};typedef struct stack /用该栈来模拟临时让出的车辆的停靠场地/ {struct rangweicar HMAXSIZE;int topp;}SqStackk;define QNODE struct QnodeQNODE { int data; /链队结点的类型/QNODE next;};typedef struct linkqueue /用该链队来模拟便道/{QNODE front,rear;int geshu;}LinkQueue;void Judge_OutputSqStack s,LinkQueue q,struct car r /该算法通过传递来的车辆信息调{ 用相关函数实现操作/ ifr.bb=='E'||r.bb=='e' /若车辆状态为‘E’,终止程序/printf"STOP\n";else ifr.bb=='P'||r.bb=='p' /若车辆状态为‘P’,输出停车场车辆数/ printf"The number of parking cars is %d\n",s->top+1;else ifr.bb=='W'||r.bb=='w' /若车辆状态为‘W’,输出便道车辆数/ printf"The number of waiting cars is %d\n",q->geshu;else ifr.bb=='A'||r.bb=='a' /若车辆状态为‘A’,调用A_cars函数/A_carss,q,r;else ifr.bb=='D'||r.bb=='d' /若车辆状态为‘D’,调用D_cars函数/D_carss,q,r;elseprintf"ERROR\n"; /若车辆状态为其他字母,报错/}A_carsSqStack s,LinkQueue q,struct car a /该算法实现对车辆状态为到达的车辆的操{QNODE t; 作/ifs->top=n-1 /若停车场还没有满,则车进停车场,并存入车辆的状态,车牌编{s->top++; 号和到达时间信息/s->Gs->top.bb=;s->Gs->top.num=;s->Gs->top.time=;}else{printf"The parking place is full\n"; /若停车场已满,车进便道,并显示该车的车牌编t=QNODE mallocsizeofQNODE; 号,同时记录便道车辆数目/t->data=;t->next=NULL;q->rear->next=t;q->rear=t;printf"the number of the car in the access road is:%d\n",q->rear->data;q->geshu++;}}int D_carsSqStack s,LinkQueue q,struct car d /该算法实现车辆状态为离开的车{int i,j,l; 辆的操作/float x,y;QNODE p;SqStackk k;if==s->Gs->top.num /若待离开车为最后进停车场的车的情况/{x=s->Gs->top.time;y=feex; /直接计算停车时间,费用并离去/printf"The time is %.2f hours,the fee is %.2f yuan\n",x,y;ifq->geshu==0 /若便道上无车,函数返回/{printf"The queue is empty\n";return 0;}Else /若便道上有车,第一辆车进停车场/{p=q->front->next;q->front->next=p->next;s->Gs->top.num=p->data; /并存入其车牌编号及进停车场的时间/s->Gs->top.time=;freep;q->geshu--;ifq->front->next==NULLq->rear=q->front; /若此时便道上无车,返回1/return 1;}}Else /待离开的车不是最后进停车场的那辆车的情况/ {fori=0;i<s->top;i++ /先找到待离开车在停车场中的位置/ {ifs->Gi.num= continue;else break;}ifi>=s->top{printf"ERROR\n";return -1;}x=s->Gi.time; /计算待离开车的停车时间并计算费用/y=feex;printf"The time is %.2f hours,the fee is %.2f yuan\n",x,y;k=SqStackk mallocsizeofSqStackk; /设立一个新栈临时停放为该车离开而让k->topp=-1; 路的车辆/forj=s->top;j>i;j--{k->topp++; k->Hk->topp.num=s->Gj.num;k->Hk->topp.time=s->Gj.time;s->top--;}forl=0;l<=k->topp;l++{printf"the informationnumber and time in the new stack is:\n";printf"%d,%d\n",k->Hl.num,k->Hl.time;} /显示在新栈中的车辆信息/ s->top--;whilek->topp>=0 /将新栈中的车重新开入停车场中/{s->top++;s->Gs->top.bb='A';s->Gs->top.num=k->Hk->topp.num;s->Gs->top.time=k->Hk->topp.time;k->topp--;}ifq->geshu==0 /若便道上无车,则返回2,无车开入停车场中/ {printf"The access road is empty\n";return 2;}Else /若便道上有车,则第一辆车开入停车场中/{s->top++;p=q->front->next;q->front->next=p->next;s->Gs->top.num=p->data;s->Gs->top.time=;freep;q->geshu--;ifq->front->next==NULLq->rear=q->front;return 3;}}}main{SqStack s;LinkQueue q;QNODE p;struct car aaMAXSIZE;int i;s=SqStack mallocsizeofSqStack; /对停车场初始化/s->top=-1;q=LinkQueue mallocsizeofLinkQueue;p=QNODE mallocsizeofQNODE; /对便道初始化/p->next=NULL;q->front=q->rear=p;q->geshu=0;printf"\n";printf" \n";printf" 停车场管理系统\n";printf" \n";printf"\n";fori=0;i<MAXSIZE;i++ /输入车辆信息/ {printf"Please input the state,number and time of the car:\n"; scanf"%c,%d,%d",&aai.bb,&aai.num,&aai.time; getchar;Judge_Outputs,q,&aai;ifaai.bb=='E' break;}}。
数据结构停车场管理实验报告C++
数据结构课程设计题目停车场管理器设计专业:计算机科学与技术班级:1401姓名:彭旭学号:143230135实验主要内容以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入的输入数据序列进行模拟管理。
每一组输入数据包括三个数据项:汽车“达到”或“离去”信息、汽车牌照号码以及达到或离去的时刻。
对每一组输入数据进行操作后的输出信息为:若是车辆达到、则输出汽车在停车场内或便道上停车位置;若是车辆离去,则输出汽车在停车场内停留的时间和应交纳的费用(在便道上停留的时间不收费)。
栈以顺序结构实现,队列以链表结构实现。
环境Windows 10 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}基本操作:Ini tStack(&S)操作结果:构造一个空栈SoPush(&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为队尾基本操作:Ini tQueue(&Q);操作结果:构造一个空队列QEn Queue(&Q, &e);初始条件:对列Q已存在。
操作结果:插入元素e为Q的新队尾元素。
DeQueue(&Q, &e);初始条件:对列Q已存在。
操作结果:删除Q的队头元素,并用e返回。
}ADT Queue(2)本程序包含七个模块:<1>主程序模块,其中主函数为Void mai n(){初始化;构造空栈;输入已知数据;插入数据入栈;分析{入栈;出栈;入队;出队;}输出数据;}<2>构造栈模块——构造一个空栈;「构造栈模块][栈插入模块][栈删除模块][构造队列模块][队列插入模块][队列删除模块2.详细设计<1>类型定义#define STACK_INIT_SIZE 100#defi ne STACKINCREMENT 10#defi ne MONE Ytypedef int Status;typedef struct ElemType{char a⑶;int num;int time;}ElemType;typedef struct SqStack {ElemType *base;〃在栈构造之前和销毁之后,base的值为NULLElemType *top;〃栈顶指针int stacksize;//当前已经分配的存储空间,以元素为单位}SqStack;〃栈的表示typedef struct QNode{ElemType data;struct QNode *n ext;}QNode,*QueuePtr;〃队列的表示typedef struct Lin kQueue{QueuePtr fron t;〃队头指针QueuePtr rear;// 队尾指针}Lin kQueue;<2>栈和队列的基本操作Status In itStack(SqStack &S)//构造一个空栈Status Push(SqStack &S,ElemType e)//插入元素e为新的栈顶元素Status Pop(SqStack &S,ElemType &e)//若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK ;否贝V返回ERRORStatus Ini tQueue(L in kQueue &Q)//构造一个空队列QStatus En Queue(L in kQueue &Q,ElemType e)//插入元素e为Q的新队列Status DeQueue(L in kQueue &Q,ElemType &e)//若队列不空,则删除Q的对头元素,用e返回其值,并返回Ok;否则返回ERROR;<3>部分操作的算法Status In itStack(SqStack &S){// 构造一个空栈S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));if(!S.base) exit (OVERFLOW);S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status Push(SqStack &S,ElemType e){〃插入元素e 为新的栈顶元素if(S.top-S.base>=S.stacksize){〃栈满,追加存储空间S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(EI emType));if(!S.base) exit(OVERFLOW);// 存储分配失败S.top=S.base+S.stacksize;S.stacksize+=STACK_INIT_SIZE;}*S.top++=e;return OK;}Status Pop(SqStack &S,ElemType &e){//若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERRORif(S.top==S.base) return OK;e=*--S.top;return OK;}// --------- 队列Status Ini tQueue(Li nkQueue &Q){〃构造一个空队列Q Q.fro nt=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.fro nt) exit (OVERFLOW);// 存储分配失败Q.fro nt-> next=NULL;return OK;}Status EnQueue(LinkQueue &Q,ElemType e){〃插入元素e 为Q的新队列p=(QueuePtr)malloc(sizeof(QNode));〃存储分配失败if(!p) exit(OVERFLOW);p->data=e;p->n ext=NULL;Q.rear- >n ext=p;Q.rear=p;return OK;}Status DeQueue(L in kQueue &Q,ElemType &e){//若队列不空,则删除Q的对头元素,用e返回其值,并返回Ok; 否则返回ERROR;if(Q.fro nt==Q.rear) return ERROR;p=Q.fr ont->n ext;e=p->data;Q.fro nt->n ext=p->n ext;if(Q.rear==p) Q.rear=Q.fr ont;free(p);return OK;}源程序Stopl.h:#i nclude <stdio.h>#i nclude <process.h>#i nclude <malloc.h>#in clude <stri ng.h>// -------------- 函数结果状态代码#defi ne TRUE 1#defi ne FALSE 0#defi ne OK 1#defi ne ERROR 0#defi ne TNFEASIBLE -1#defi ne OVERFLOW -2//Status 是函数的类型,其值是函数结果状态代码typedef int Status;#defi ne STACK_INIT_SIZE 100#defi ne STACKINCREMENT 10#defi ne MONEY 3Stop2.h:#i nclude"stop1.h"typedef struct ElemType{char a[3];int num;int time;}ElemType;typedef struct SqStack{ElemType *base;ElemType *top;int stacksize;}SqStack;〃栈的表示typedef struct QNode{ElemType data;struct QNode *n ext;}QNode,*QueuePtr;〃队列的表示typedef struct Lin kQueue{QueuePtr fron t;〃队头指针QueuePtr rear;// 队尾指针}Lin kQueue;Status In itStack(SqStack &S);〃构造空栈Status Push(SqStack &S,ElemType e);〃进栈Status Pop(SqStack &S,ElemType &e);〃出栈Status Ini tQueue(L in kQueue &Q);〃构造一个空队列Status En Queue(L in kQueue &Q,ElemType e);〃入队Status DeQueue(Li nkQueue &Q,ElemType &e);〃出队Stop.cpp:#in clude"stop2.h"Status In itStack(SqStack &S){// 构造空栈S.base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType)); if(!S.base) exit(OVERFLOW);S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status Push(SqStack &S,ElemType e){// 插入元素 e 为新的栈顶元素if(S.top-S.base>=S.stacksize){〃栈满,追加存储空间S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemType)); if(!S.base)队列*/exit(OVERFLOW);S.top=S.base+S.stacksize;S.stacksize+=STACK_INIT_SIZE;}*S.top++=e;return OK;}Status Pop(SqStack &S,ElemType &e){// 出栈if (S.top==S.base) return OK;e=*--S.top;return OK;}/***********************************************************************Status Ini tQueue(L in kQueue &Q){// 构造一个空队列Q.fro nt=Q.rear=(QueuePtr)malloc(sizeof(QNode)); if(!Q.fro nt) exit(OVERFLOW); Q.fro nt-> next=NULL;return OK;}Status EnQueue(LinkQueue &Q,ElemType e){〃插入元素 e 为 Q 的新队列 struct QNode *p;p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(OVERFLOW);p->data=e;p->n ext=NULL;Q.rear- >n ext=p;Q.rear=p;return OK;}Status DeQueue(L in kQueue &Q,ElemType &e){struct QNode *p;if(Q.fro nt=Q.rear) return ERROR;p=Q.fr ont->n ext=p->n ext;if(Q.rear==p) Q.rear=Q.fr on t;free(p);return OK;}Stop_ma in. cpp:#i nclude"stop2.h"时间空格隔 mai n(){int i,t,f,m, n,s1_ num,Q_num;struct SqStack s1,s2;struct Lin kQueue Q;struct ElemType e,e1;s1_num=0;Q_num=0;t=0;m=0;In itStack(s1);l nitStack(s2);l ni tQueue(Q);printf("停车场的容量是:”);scan f("%d",&n);printf("输入车辆信息(E 为退出,A 为进入标志,D 为离开标志,车牌号 开):\n"); scan f("%s",e1.a);sca nf("%d%d", &e1. num, &e1.time); while(strcmp(e1.a,"E")!=0){if(strcmp(e1.a,"A")==0) {// 当有车辆进来的时候if(s1_ num<n) {Push(s1,e1);s1_ nu m++;printf("此车停在停车场第%d 辆\n",s1_num);}else {En Queue(Q,e1);Q_ nu m++;printf("此车停在便道距离门口第 %d 辆\n",Q_num);}}else if(strcmp(e1.a,"D")==0) {// 当有车辆离开的时候f=s1_num;for(i=0;i<f;i++){Pop(s1,e);s1_ nu m__;if(e1. num==e. nu m){ t=e1.time-e.time;m=M0NEY*t;printf (”此车停车时间 %d,所需费用%d 元\n",t,m);break;} else Push(s2,e);}if(t==0&&m==0){printf(" 此车为便道内车,故无需收费 \n");Q_num--;} while(s2.top!=s2.base){Pop(s2,e);Push(s1,e);s1_num++;}if(Q.fro nt!=Q.rear){DeQueue(Q,e);Push(s1,e);s1_ nu m++;}}else printf (” 错误 \n");printf("输入数据 \n");sca nf("%s",e1.a);sca nf("%d%d", &e1. num, &e1.time);}运行结果 tin-' 11-停车场第;!輛 辆 a 时进入标志,D 为离开柝志,车胆号时间空格隔开) exited after 63.54 seconds uith retuii'n ualuie Q i 青按任意键继綾…口 L:'数裾结构稈序\谆在场管理;停车场WH.exe。
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 为新的栈顶元素。
停车场管理系统 C语言实习报告
C语言课程实习报告【要求】设有一个可以停放n辆汽车的狭长停车场,它只有一个大门可以供车辆进出。
车辆按到达停车场时间的早晚依次从停车场最里面向大门口停放(最先到达的第一辆车放在停车场的最里面)。
如果停车场已放满n辆车,则后来的车辆只能在停车场大门外的便道上等待,一旦停车场内有车开走,则排在便道上的第一辆车就进入停车场。
停车场内如有某辆车要开走,在它之后进来的车都必须先退出停车场为它让路,待其开出停车场后,这些车辆再依原来的次序进场。
每辆车在离开停车场时,都应依据它在停车场内停留的时间长短交费。
如果停留在便道上的车未进停车场就要离去,允许其离去,不收停车费,并且仍然保持在便道上等待的车辆的次序。
编制一程序模拟停车场管理。
【提示】汽车的模拟输入信息格式可以是:(到达/离去,汽车牌照号码,到达/离去的时刻)。
基本要求:要求程序输出每辆车到达后的停车位置(停车场或便道上),以及某辆车离开停车场时应交纳的费用和它在停车场内停留的时间。
根据题目要求,停车场可以用一个长度为n 的堆栈来模拟。
由于停车场内如有某辆车要开走,在它之后进来的车辆都必须先退出停车场为它让路,待其开出停车场后,这些车辆再依原来的次序进场,所以可以设两个堆栈。
一、需求分析根据题目要求,程序应该提供“到达/离去,汽车牌照号码,到达/离去”的输入、输出操作;在程序中需要浏览停车场的车位信息,应提供显示、查找、排序等操作;此外还应提供键盘式菜单实现功能选择。
二、总体设计:根据需求分析,可以将系统的设计分为以下五大模块:(1)车辆进入;(2)车辆退出;(3)车辆等待;(4)车辆查询;(5)退出。
一、详细设计:主函数中只包含菜单函数,菜单部分单独写成函数,只提供输入、功能处理和输出部分的函数调用,其中各功能模块用菜单方式选择。
[程序]#define N 30 /*等待车辆*/#define M 20 /*车位*/#define P 2 /*单位时间所收费用*/#include<stdio.h>#include<stdlib.h>#include<string.h>struct cars /*定义车辆信息*/{ char state;int num;int in_time; 停车场管理系统车辆进入 车辆退出 车辆等待 车辆信息显示车辆查询 退出系统int out_time;int time_spend;int money_to_pay;}car[M];struct carleft{ char state;int num;}wait[N];1、主函数模块[流程图][程序]main() /*主函数*/{pre_manage();menu(); /*调用主菜单函数*/return 0;}void menu() /*主菜单函数*/{int n,w;do{puts("\t\t************************MENU*******************\n\n");puts("\t\t\t\t 1.car_arrive"); /*有车到来*/puts("\t\t\t\t 2.car_depart"); /*有车离开*/puts("\t\t\t\t 3.car_browse"); /*浏览车位信息*/ puts("\t\t\t\t 4.exit"); /*退出*/ puts("\n\n\t\t *********************************************\n") printf("Choice your number(1-4):[ ]\b\b"); /*选择所需服务*/scanf("%d",&n);getchar();if(n<1||n>4){ w=1; getchar();}else w=0;} while(w==1);switch(n){case 1: car_arrive();break;case 2: car_depart();break;case 3: car_browse();break;case 4: exit(0);}}void pre_manage() /*循环结构*/{ int i;for(i=0;i<M;i++)car[i].state='E';for(i=0;i<N;i++)wait[i].state='E';}2、各功能模块设计:(1)、车辆进入模块[分析]车辆进入停车场后,判断车位和等待车位是否有剩余。
c语言实习报告 停车场管理系统.pptx
if((fp=fopen("car.dat","w")) ==NULL) {
fprintf(stderr,"error opening file\n"); exit(1);
8
" ); }
7.退出模块 if(a== '0')
{
学海无 涯
printf(" press any key to continue... " ); break;
四.实习心得
在老师的带领下进行了 C 语言程序实践学习。在短短一周的实 习期间使我获取了不少新知识也巩固了许多老知识。在这之前,我们 已经对 C 语言这门课程学习了一个学期,对其有了一定的了解,但 是也仅仅是停留在学习了解的范围,对里面的好多东西还是很陌生, 并不是很熟练,有着许多欠缺,更多的在运用起来的时候还是感到很 不好动手。
for (j = 0; j<2;++j)
{
for (k = 0; k<6;++k)
{
if(park[j][k] !=0)
printf("%d
%d
%d
%d \n
",car[j*6+k].carNO,car[j*6+k].floor,car[j*6+k].position,car[j*6+k].time);
学海无 涯
C 语言课程设计
院系:工程学院 姓名:姚 品 品 学号:20051001635 班号:05205224 指导教师:王老师 日期:2007 年 9 月
1
学海无 涯
一 课程设计编号、名称、内容
编号:第二十七题
C语言课设之停车场管理系统
C语言课程设计实习报告目录一. 题目要求二. 需求分析三.总体设计四. 具体程序五. 上机操作及使用说明六. 存在问题与不足七. 学习心得停车场管理一. 题目要求1.设计一个停车场用长度为N的堆栈来模拟。
由于停车场内如有某辆车要开走,在它之后进来的车都必须先退出为它让道,待其开出停车场后,这些车再依原来的顺序进入。
2.程序输出每辆车到达后的停车位置,以及某辆车离开停车场时应交纳的费用和它在停车场内停留的时间。
二. 需求分析根据题目要求首先设计一个堆栈,以堆栈来模拟停车场,又每辆汽车的车牌号都不一样,这样一来可以根据车牌号准确找到汽车位置,所以堆栈里的数据元素设计成汽车的车牌号。
当停车场内某辆车要离开时,在它之后进入的车辆必须先退出车场为它让路,待该辆车开出大门外,其他车辆再按原次序进入停车场。
这是个一退一进的过程,而且让道的汽车必须保持原有的先后顺序,因此可再设计一个堆栈,以之来暂时存放为出站汽车暂时让道的汽车车牌号。
当停车场满后,继续进来的汽车需要停放在停车场旁边的便道上等候,若停车场有汽车开走,则按排队的先后顺序依次进站,最先进入便道的汽车将会最先进入停车场,这完全是一个先进先出模型,因此可设计一个队列来模拟便道,队列中的数据元素仍然设计成汽车的车牌号。
另外,停车场根据汽车在停车场内停放的总时长来收费的,在便道上的时间不计费,因此必须记录车辆进入停车场时的时间,车辆离开停车场时的时间不需要记录,当从终端输入时可直接使用。
由于时间不像汽车一样需要让道,可设计了一个顺序表来存放时间。
又用顺序表用派生法设计了一个堆栈,恰好满足上面模拟停车场的需要。
三. 总体设计四. 具体程序#include <stdio.h>#include <malloc.h> #define SIZE 3#define NULL 0 typedef struct{ int hour;int min;} time;typedef struct{ int num;int position;time t;float money;} Car;typedef struct{ Car elem[SIZE+1]; int top;} Stack;typedef struct Node { Car data;struct Node *next; }CQueueNode;typedef struct{ CQueueNode *front;CQueueNode *rear;}LinkQueue;void InitStack(Stack *S){ S->top=0; }void Push(Stack *S,Car *r){ S->top++;S->elem[S->top].num=r->num;r->position=S->elem[S->top].position=S->top;S->elem[S->top].t.hour=r->t.hour;S->elem[S->top].t.min=r->t.min;}int IsEmpty(Stack* S){ return(S->top==0?1:0); }int IsFull(Stack *S){ return(S->top==SIZE?1:0); }int GetTop(Stack *S,Car *n){ n->num=S->elem[S->top].num;n->position=S->elem[S->top].position;n->t.hour=S->elem[S->top].t.hour;n->t.min=S->elem[S->top].t.min;return 1;}void InitQueue(LinkQueue *Q){ Q->front=(CQueueNode*)malloc(sizeof(CQueueNode)); if(Q->front!=NULL){ Q->rear=Q->front;Q->front->next=NULL; }}int EnterQueue(LinkQueue *Q,Car *t){ CQueueNode *NewNode;NewNode=(CQueueNode*)malloc(sizeof(CQueueNode)); if(NewNode!=NULL){NewNode->data.num=t->num;NewNode->data.t.hour=t->t.hour;NewNode->data.t.min=t->t.min;NewNode->next=NULL;Q->rear->next=NewNode;Q->rear=NewNode;return 1;}else return 0;}{ CQueueNode *p;if(Q->front==Q->rear)return 0;p=Q->front->next;Q->front->next=p->next;if(Q->rear==p)Q->rear=Q->front;x->num=p->data.num;x->t.hour=p->data.t.hour;x->t.min=p->data.t.min;free(p);return 1;}void print1(Stack *S){int tag;Car x;printf("停车场停车情况:\n");if(IsEmpty(S))printf("无车!");for(tag=S->top;S->top>0;S->top--)if(GetTop(S,&x))printf("车牌号%d,所在位置%d,到达/离开时间 %d:%d\n",x.num,x.position,x.t.hour,x.t.min);S->top=tag;}void print2(LinkQueue *Q){ CQueueNode *p;p=Q->front->next;for(;p!=NULL;p=p->next)printf("等待车牌号%d, 到达/离开时间 %d:%d",p->data.num,p->data.t.hour,p->data.t.min);}void TaM(Car *r,int h,int m){ if(m>r->t.min){r->t.min+=60;r->t.hour-=1;}h=r->t.hour-h;m=r->t.min-m;printf("\n停车 %d小时 %d 分钟\n",h,m);printf("每小时收费30元\n");h=h*60;m=h+m;r->money=0.5*m;printf("请支付金额%.2f元\n",r->money);}{if(IsFull(S)){ printf("车库已满,请等待!");EnterQueue(Q,r);}else{Push(S,r);printf("\n您现在所在位置 %d",r->position);}}void Out(Stack *S,Stack *S0,Car *r,LinkQueue *Q){ int tag=S->top;Car x;if(IsEmpty(S)) printf("没有此车!");else{ for(;r->num!=S->elem[tag].num&&tag>0;tag--){ Push(S0,&S->elem[tag]);S->top--;}if(r->num==S->elem[tag].num){ TaM(r,S->elem[tag].t.hour,S->elem[tag].t.min);S->top--;for(;S0->top>0;S0->top--)Push(S,&S0->elem[S0->top]);if(S->top<SIZE && Q->front!=Q->rear){ DeleteQueue(Q,&x);Push(S,&x);}}else if(tag==0){ printf("未进入停车场应支付金额 0元!");for(;S0->top>0;S0->top--)Push(S,&S0->elem[S0->top]);}}}void print(){printf("\n***********************************欢迎光临*************************************\n");printf("\n 请选择:\n");printf("\n 1 :到达");printf("\n 2 :离开");printf("\n 3 :搜索");printf("\n 4 :退出\n");printf("\n");}int main(){ int n,m,i=1,j,flag=0;Car c[10];Car x;Stack S,S0;LinkQueue Q;InitStack(&S);InitStack(&S0);InitQueue(&Q);while(1){ print();scanf("%d",&m);switch(m){case 1:printf("\n请输入车牌号:");scanf("%d",&c[i].num);printf("\n请输入到达/离开时间:");scanf("%d:%d",&c[i].t.hour,&c[i].t.min); In(&S,&Q,&c[i]);i++;break;case 2:printf("\n请输入车牌号:");scanf("%d",&n);for(j=0;j<10;j++)if(n==c[j].num) break;printf("\n请输入到达/离开时间:");scanf("%d:%d",&c[j].t.hour,&c[j].t.min); Out(&S,&S0,&c[j],&Q); break;case 3: print1(&S);print2(&Q);break;case 4: flag=1; break;default:printf("\n输入错误,请输入 1,2,3 或4"); }if(flag)break;} return 0;}五. 上机操作及使用说明运行Microsoft Visual C++,进入运行状态:1.主菜单:根据页面提示,输入相应数字。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1.头文件及宏定义
#include <conio.h> #include <malloc.h> #include <stdio.h> #include <stdlib.h> #include <windows.h> #define ClearScreen() system( "cls" ) // 清空当前屏幕 #define setcolor() system("color 2f")//设置背景前景颜色 #define Pause( szPrompt ) printf( "%s", szPrompt ),getch()
//设置背景前景颜色
#define setcolor() system("color 2f")
// 显示字符串 szPrompt 并等待用户按下任意键
#define Pause( szPrompt ) printf( "%s", szPrompt ),getch() typedef struct carinformation // 车辆信息
实现过程
1.开始界面:输入车库容量
2.输入车辆到达信息
2
学海无 涯
3.当车库停满车时临时停到便道上不收车费
4.车辆离开后车库有车位便道上的车进入车库并显示离去车 的收费记录
5.显示车库及便道信息
3
学海无 涯
6.停止输入显示制作者信息及退出程序
实训心得
通过这次实训我对课本上的理论知识有了更深层次的了解,可能在仅一周 的时间内学到的东西有限,不过却也是受益非浅,实训本来就是对平常所学的 理论知识通过具体的实现表示出来是在完成理论课程学习之后安排的综合实践 训练,任何一个优秀的程序员都是从实践中获得经验和教训的。经过仅仅一周 的实训从总体上说收获是很不错的!
{ char szRegistrationMark[64]; // 车牌号 char szArrivalTime[16]; // 到达时间 char szEntranceTime[16]; // 进入停车场(开始计费)时间 char szDepartureTime[16]; // 离开时间
} TCARINFORMATION, *LPTCARINFORMATION;
2.时间和汽车信息结构体的定义(部分代码)
typedef struct carinformation // 车辆信息 {
char szRegistrationMark[64]; // 车牌号 char szArrivalTime[16]; // 到达时间 char szEntranceTime[16]; // 进入停车场(开始计费)时间 char szDepartureTime[16]; // 离开时间 } TCARINFORMATION, *LPTCARINFORMATION;
首先代码的编写能力明显提高,有了想法基本都能顺利表达出来;再者就 是数据结构的选择使用能力也有了很大的提高!虽然,平时的实验课我们也有用 各种数据做题,但那些都是很明确的该做什么操作,存什么,我们的发挥空间不 大一般照做就行,然而这次实习我们却是在自主的选择判断,这本身就是一个很 大的提高!
但是还是很多的知识不了解,不过收获真的很多,但是最大的收获可能就是 对编程的兴趣吧,在一次次的改掉错误,一次次的完成想要的效果后,越写越有 感觉,越写越有成就感!当然还收获了无知,更确切的说是自知,原来我们现在 什么也不算,还有很多有用的知识等着我们去学习!
1
学海无 涯
3.栈和队列的定义(部分代码)
typedef struct carqueue
// 链队
{ LPTCARNODE lpHead; // 头结点 LPTCARNODE lpRear; // 指向当前队尾的指针 int nEffectiveSize; // 当前队中元素个数
} TCARQUEUE, *LPTCARQUEUE;
学海无涯
设停车场内只有一个可停放 n 辆汽车的狭长通道,且只有一个大门可供汽车 进出。汽车在停车场内按车辆到达时间的先后顺序,依次由北向南排列(大门在 最南端,最先到达的第一辆车停放在车场的最北端),若车场内已停满 n 辆汽车, 则后来的汽车只能在门外的便道上等候,一旦有车开走,则排在便道上的第一辆 车即可开入;当停车场内某辆车要离开时,在它之后开入的车辆必须先退出车场 为它让路,待该辆车开出大门外,其它车辆再按原次序进入车场,每辆停放在车 场的车在它离开停车场时必须按它停留的时间长短交纳费用。试为停车场编制按 上述要求进行管理的模拟程序。
4
附录(代码)
学海无 涯
#include <conio.h>
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
ห้องสมุดไป่ตู้
#include <windows.h>
// 清空当前屏幕
#define ClearScreen() system( "cls" )
4.栈和队列的初始化(部分代码)
void InitQueue( LPTCARQUEUE &lpCarQueue ) {
lpCarQueue = ( LPTCARQUEUE ) malloc( sizeof( TCARQUEUE ) ); lpCarQueue->lpHead = ( LPTCARNODE) malloc( sizeof( TCARNODE ) ); lpCarQueue->lpHead->lpNext = NULL; lpCarQueue->lpRear = lpCarQueue->lpHead; lpCarQueue->nEffectiveSize = 0; }
功能描述
以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入的输入数据序 列进行模拟管理。每一组输入数据包括三个数据项:汽车“到达”或“离去”信 息、汽车牌照号码及到达或离去的时刻,对每一组输入数据进行操作后的输出数 据为:若是车辆到达,则输出汽车在停车场内或便道上的停车位置;若是车离去; 则输出汽车在停车场内停留的时间和应交纳的费用(在便道上停留的时间不收 费)。栈以顺序结构实现,队列以链表实现