用栈模拟停车场_数据结构课程设计实验报告-模拟停车场管理问题

合集下载

实验二栈和队列实验报告---停车场问题

数据结构实验报告实验二栈和队列实验班级：计12-2 姓名：毛文祥学号12101020223一.实验目的熟悉栈和队列的基本特性，掌握栈和队列基本运算的实现过程。

重点掌握栈和队列各种操作的实现。

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

三.需求分析该停车场问题可以理解为栈和队列的结合，因为停车场内部是先进入的车辆放到最北面，之后进来的车辆依次排到南面，如果有车辆要出去，那么在它之后进入的车辆必须先退出，给这个车辆让路，这个车辆出去之后再返回到停车场，这就是栈的先进后出的操作一致，因此选择栈存储停车场内的车辆，而便道上的车辆则不同，便道上的车辆，进来之后就排在最西边，如果有车辆要出去，那么在它之前车辆必须依次排到队尾，之后这个车辆开出便道，这和队列的先进先出操作一致，因此用队列存储便道上的车辆。

四.系统设计1.数据结构定义：struct Park{int status;//车的状态,0表示进入,1表示离开int num;//车的牌号int time;//车离开或者进入的时间};//车的基本信息的结构体定义typedef struct{struct Park *base;//栈底指针struct Park *top;//栈顶指针int stacksize;}SqStack;栈数据结构定义队列数据结构类型定义typedef struct QNode{struct Park data;//数据域struct QNode *next;}QNode,*Queueptr;typedef struct{Queueptr front;//队头指针Queueptr rear;//队尾指针}LinkQueue;2.基本操作描述void InitStack(SqStack &S);//初始化一个栈void Push(SqStack &S,struct Park e);//压入一个栈顶元素struct Park GetTop(SqStack &S);//得到栈顶元素,函数的返回值为存放车的信息的结构体变量struct Park Pop(SqStack &S);//删除栈顶元素，且函数的返回值为栈顶元素int EmptyStack(SqStack S);//判断一个栈是否为空，空返回1，非空返回0void VisitStack(SqStack S);//遍历一个栈而且输出栈元素的信息,输出顺序为从栈底元素到栈顶元素 void InitQueue(LinkQueue &Q);//初始化一个队列void InsertQueue(LinkQueue &Q,struct Park e);//在队列的队尾处中插入一个元素void DeleteQueue(LinkQueue &Q);//删除队头元素void VisitQueue(LinkQueue Q);//遍历队列，且输出队列元素信息,按照从队头到队尾的顺序输出void DQueue(LinkQueue &Q,struct Park e);//在队列中删除元素信息的数据域中的num值和e的num相等的元素int DStack(SqStack &S,struct Park p,double &d);//在栈中查找是否有与p的num值相等的元素，如果找到，改变d的值，函数值返回1，否则函数值返回03.主程序模块处理过程描述首先输入该车辆信息，判断是否是输入结束标志，是则跳出循环，否则判断是否是进入的车辆，如果是进入的车辆，那么判断此时栈是否已经满了，如果此时栈已满，那么该车辆就要入队列，否则入栈。

栈和队列课程设计停车场管理

课程设计2 栈和队列课程设计一、1、停车场管理问题描述：停车场是一个能放n辆车的狭长通道，只有一个大门，汽车按到达的先后次序停放。

若车场满了，车要停在门外的便道上等候，一旦有车走，则便道上第一辆车进入。

当停车场中的车离开时，由于通道窄，在它后面的车要先退出，待它走后在依次进入。

汽车离开时按停放时间收费。

基本功能要求：（1）建立三个数据结构分别是：停放、让路、等候。

（2）输入数据模拟管理过程，数据（入或出，车号）。

停车场管理#include<iostream>using namespace std;#define Maxsize 10//停车场共停10辆车#define maxsize 10//等待区共停10辆车typedef int datatype;typedef struct ////////////用栈表示汽车停放和让路{datatype data[Maxsize+1];int top;}Seqstack;void Initstack(Seqstack *&s){s=(Seqstack *)malloc(sizeof(Seqstack));s->top=0;}int push(Seqstack *&s,datatype e){if(s->top==Maxsize)return 0;s->top++;s->data[s->top]=e;return 1;}int pop(Seqstack *&s,datatype &e){if(s->top==0)return 0;e=s->data[s->top];s->top--;return e;}void Dispstack(Seqstack *s)int i;cout<<"车号";for(i=s->top;i>0;i--)cout<<i<<" ";cout<<endl;cout<<"停车时间";for(i=s->top;i>0;i--)cout<<s->data[i]<<" ";cout<<endl;}int Stacklength(Seqstack *s){return(s->top);}////////////////////////////////queue///////////////////////////////////// typedef struct ////////////////////用队列表示汽车等候{datatype data[maxsize+1];int front, rear;}sqqueue;void InitQueue(sqqueue *&q){q=(sqqueue *)malloc(sizeof(sqqueue));q->front=q->rear=0;}int enQueue(sqqueue *&q,datatype e){if((q->rear+1)%maxsize==q->front)return 0;q->rear=(q->rear+1)%maxsize;q->data[q->rear]=e;return 1;}int deQueue(sqqueue *&q,datatype &e){if(q->front==q->rear)return 0;q->front=(q->front+1)%maxsize;e=q->data[q->front];return 1;}int lenqueue(sqqueue *&q)return(q->rear-q->front);}void Disqqueue(sqqueue *q)//输出队列元素{if(q->front==q->rear)cout<<"No element!"<<endl;cout<<"The elemnt in this Sqqueue is:"<<endl;while(q->front!=q->rear){cout<<q->data[q->front+1]<<" ";q->front++;}q->front=0;cout<<endl;}void menu(){cout<<"------------Welcome to our Car Parking-----------------"<<endl;cout<<"1-----------停车"<<endl;cout<<"2-----------离开"<<endl;cout<<"3-----------查看停车场停车情况"<<endl;cout<<"4-----------退出"<<endl;}void current(Seqstack *&s1,sqqueue *&q){cout<<"* * * * * * * * 目前停车场状况* * * * * * * * *"<<endl;cout<<"停车场共"<<Maxsize<<"个车位,"<<"当前停车场共有"<<s1->top<<"辆车.";cout<<"等待区共有"<<lenqueue(q)<<"辆车."<<endl;cout<<"* * * * * * * * * * * * * * * * * * * * * * * "<<endl;}void chargemoney(Seqstack *s)//收费系统，按每小时2元钱{cout<<"收取车号为"<<s->top<<"的车,停车费"<<(s->data[s->top])*2<<"元."<<endl;}int main(){Seqstack *s1,*s2;sqqueue *q;Initstack(s1);Initstack(s2);InitQueue(q);int a[8]={10,20,30,40,50,60,70,80};for(int i=0;i<8;i++)push(s1,a[i]);int In;datatype x,e;current(s1,q);do{menu();cin>>In;switch(In){case 1:int time;cout<<"请输入停放时间(/小时，每小时2元):"<<endl;cin>>time;if(push(s1,time)!=0)cout<<"您的车号是:"<<s1->top<<endl;else{enQueue(q,time);cout<<"停车场已满,请稍等..."<<endl;cout<<"等待车号为"<<q->rear<<endl;}current(s1,q);break;case 2:cout<<"请输入车号:"<<endl;int num;cin>>num;for( i=Stacklength(s1);i>num;i--){pop(s1,x);push(s2,x);} chargemoney(s1);pop(s1,x);for(i=Maxsize;i>num;i--){pop(s2,x);push(s1,x);}if(q->front!=q->rear){deQueue(q,e);push(s1,e);cout<<"等待车号为"<<q->front<<"的车,进入停车场,停车车号为"<<s1->top<<endl;}current(s1,q);break;case 3:Dispstack(s1);break;case 4:break;default:cout<<"error input!"<<endl;}}while(In!=4);return 0;}实验结果截图：。

停车系统实验报告

一、实验背景随着城市化进程的加快，汽车数量不断增加，停车难问题日益突出。

为了提高停车效率，减少交通拥堵，实现停车场管理的智能化，我们设计并实现了一个基于数据结构的停车场管理系统。

本系统采用栈和队列数据结构模拟停车场的运行过程，实现了车辆进出、停车位置分配、费用计算等功能。

二、实验目的1. 理解并掌握栈和队列数据结构在停车场管理中的应用。

2. 设计并实现一个停车场管理系统，实现车辆进出、停车位置分配、费用计算等功能。

3. 体会数据结构在实际问题中的应用价值。

三、实验内容1. 系统设计（1）数据结构设计停车场：采用顺序栈实现，栈顶表示停车场最北端，栈底表示停车场最南端。

便道：采用链队列实现，队首表示便道最北端，队尾表示便道最南端。

汽车信息：定义一个结构体，包含车牌号、到达时间、离开时间、停车费用等属性。

（2）功能模块设计进出停车场：根据车辆到达或离开的时间，判断车辆是进入停车场还是离开停车场。

停车位置分配：根据停车场和便道的实际情况，为车辆分配停车位置。

费用计算：根据车辆在停车场停留的时间，计算停车费用。

输出结果：输出每辆车到达后的停车位置、离开时的费用和停留时间。

2. 系统实现（1）数据结构实现顺序栈：使用数组实现，提供入栈、出栈、判空等操作。

链队列：使用链表实现，提供入队、出队、判空等操作。

（2）功能模块实现进出停车场：根据车辆到达或离开的时间，判断车辆是进入停车场还是离开停车场。

停车位置分配：根据停车场和便道的实际情况，为车辆分配停车位置。

费用计算：根据车辆在停车场停留的时间，计算停车费用。

输出结果：输出每辆车到达后的停车位置、离开时的费用和停留时间。

3. 系统测试（1）功能测试测试车辆进出停车场功能。

测试停车位置分配功能。

测试费用计算功能。

（2）性能测试测试系统在高并发情况下的性能。

四、实验结果与分析1. 功能测试结果经过测试，系统各项功能均能正常运行，满足设计要求。

2. 性能测试结果在高并发情况下，系统运行稳定，性能良好。

数据结构实验报告—停车场问题

数据结构实验报告—停车场问题《计算机软件技术基础》实验报告I—数据结构实验二：停车场管理问题一、问题描述1.实验题目：设停车场是一个可停放 n 辆汽车的狭长通道，且只有一个大门可供汽车进出。

汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端）。

若停车场内已经停满 n 辆车，那么后来的车只能在门外的便道上等候。

一旦有车开走，则排在便道上的第一辆车即可开入。

当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其他车辆再按原次序进入车场。

每辆停放在车场的车在它离开停车场时必须按它停留的时间长短缴纳费用。

试为停车场编制按上述要求进行管理的模拟程序。

2．基本要求：以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入数据的序列进行模拟管理。

每一组输入数据包括三个数据项：汽车的“到达”（‘A’表示）或“离去”（‘D’表示）信息、汽车标识（牌照号）以及到达或离去的时刻。

对每一组输入数据进行操作后的输出信息为：若是车辆到达，则输出汽车在停车场内或者便道上的停车位置；若是车辆离去，则输出汽车在停车场停留的时间和应缴纳的费用（便道上停留的时间不收费）。

栈以顺序结构实现，队列以链表结构实现。

3．测试数据：设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’表示输入结束。

其中：（‘A’，1，5）表示1号牌照车在5这个时刻到达，而（‘D’，1，15）表示1号牌照车在15这个时刻离去。

二、需求分析1.程序所能达到的基本可能：本程序用来模拟一个可停放n辆车的停车场的停车管理问题。

数据结构停车场问题实验报告

数据结构课程设计——停车场管理问题姓名：学号：一、问题描述设有一个可以停放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));if(!S.base){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);}}elseprintf("该牌照的车已存在，输入有误，请重新输入\n");return OK;}else{printf("时间输入有误，请重新输入!\n");return FALSE;}}4）车辆离开处理Status Leave(SqStack &S,SqStack &TempS,LinkQueue &Q,CarNode &e){//车辆离开处理CarNode a;int leatime,leanum;intentertime; //进入停车场时间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{char event;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;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;}//=====================================================================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;intentertime; //进入停车场时间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;}//=====================================================================voidInitialization(){ //初始化程序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．本程序要求对车辆的动态能够输出具体的信息内容，包括停车或离开的时间，位置，及所需缴纳的停车费。

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返回。

数据结构-停车场管理系统实验报告

数据结构-停车场管理系统实验报告数据结构停车场管理系统实验报告一、实验目的本次实验旨在通过设计和实现一个停车场管理系统，深入理解和应用数据结构的知识，包括栈、队列、链表等，提高编程能力和解决实际问题的能力。

二、实验环境本次实验使用的编程语言为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 ＜＜＂停车场内没有车辆。

数据结构停车场问题实验报告

数据结构课程设计——停车场管理问题姓名：学号：一、问题描述设有一个可以停放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.测试与优化对停车场管理算法进行测试，并根据实际情况进行优化。

可以通过增加数据量、调整车辆进出顺序等方式进行测试，并根据测试结果进行优化。

实验结果：经过实验测试，停车场管理系统可以良好地处理车辆的进入和离开，并正确计算可用停车位的数量。

通过合理的停车位选择算法，确保了车辆进出的顺序。

实验总结：通过本次实验，我们学习了如何利用数据结构来实现停车场管理系统。

停车场管理系统是一种常见的实际应用，对于解决停车难问题具有重要意义。

在实验过程中，我们掌握了设计和实现停车场类、车辆类以及停车场管理算法的方法，加深了对数据结构的理解和应用。

在实验过程中，我们还发现停车场管理算法可以通过不同的策略进行优化，如最大化停车利用率、最小化顾客等待时间等。

数据结构用栈和队列创建停车场管理系统实验报告

数据结构用栈和队列创建停车场管理系统实验报告一、实验背景及目的随着城市化进程的不断加速，车辆数量急剧增长，停车难成为了城市发展中的一个重要问题。

为了解决这一问题，需要建立高效的停车场管理系统。

数据结构中的栈和队列是常用的数据结构，可以用来创建停车场管理系统。

本次实验旨在通过使用栈和队列来创建一个停车场管理系统，并测试其功能。

二、实验原理及方法1. 停车场管理系统基本原理停车场管理系统主要包括三个部分：入口、出口和停车位。

当车辆到达入口时，需要检查是否有空余的停车位；如果有，则将其分配一个位置并记录下来；否则，需要让其等待直到有空余位置。

当车辆离开时，需要释放该位置并更新记录。

2. 使用栈和队列创建停车场管理系统（1）使用栈来模拟停车位由于每个停车位只能容纳一辆汽车，可以使用栈来模拟每个停车位。

当有新的汽车进入时，将其压入栈中；当汽车离开时，则将其从栈中弹出。

（2）使用队列来模拟等待区由于等待区可以容纳多辆汽车，可以使用队列来模拟等待区。

当有新的汽车到达时，将其加入队列尾部；当有车位空余时，则从队列头部取出一辆汽车进入停车场。

3. 实验步骤（1）创建停车场管理系统的数据结构：使用栈和队列分别来模拟停车位和等待区。

（2）实现停车场管理系统的基本操作：包括汽车进入、离开、查询空余停车位等操作。

（3）测试停车场管理系统的功能：模拟多辆汽车进出停车场，检查系统是否能够正确地分配和释放停车位，并且能够正确地记录空余停车位数。

三、实验结果与分析本次实验使用栈和队列创建了一个简单的停车场管理系统，并测试了其基本功能。

在测试过程中，我们模拟了多辆汽车进出停车场，并检查了系统能否正确地分配和释放停车位。

实验结果表明，该系统可以正常工作，并且能够正确地记录空余停车位数。

四、实验总结通过本次实验，我们学习了如何使用栈和队列来创建一个简单的停车场管理系统。

同时，我们也深刻认识到数据结构在实际应用中的重要性。

在今后的学习中，我们将继续深入学习数据结构，并探索其更广泛的应用。

停车场管理程序实验报告

停车场管理程序实验报告一实验题目: 停车场管理程序二实验要求:编写一个程序实现停车场的管理功能。

并且，以栈模拟停车场，以队列模拟车场外到达便道的过程，按照从终端读入的输入数据序列进行模拟管理。

栈以顺序结构实现，队列顺序循环结构实现。

用户输入的命令有以下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.然后全程模拟即可。

数据结构实践报告--停车场管理系统

河南财经政法大学集中实践报告院系：班级：指导老师：小组：小组成员：目录（一）设计目的 (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 掌握栈和队列的基本运算。

二、实验内容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．学会了栈和队列的综合使用，更加灵活运用栈和队列。

数据结构实验报告模拟停车场管理(含代码)

模拟停车场管理班级：物联网姓名：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)时结束。

数据结构课程设计--模拟停车场管理问题

目录一、设计目的 (2)二、设计内容 (2)1.题目 (2)2.问题描述 (2)3.基本要求 (2)4.实现提示 (2)三、算法思想分析 (3)四、算法描述与实现 (4)1.数据结构类型定义 (4)2.主要算法的流程图及系统模块划分 (6)3.功能描述 (7)4.程序代码 (8)五、测试结果 (17)六、总结体会 (20)一、设计目的《数据结构》是计算机专业的核心课程，是一门实践性很强的课程。

为了学好这门课程，必须在掌握理论知识的同时，加强上机实践。

课程设计是加强学生实践能力的一个强有力手段，要求学生掌握数据结构的应用、算法的编写、将算法转换成程序并上机调试的基本方法，还要求学生在完成程序设计的同时能够写出比较规范的设计报告。

本课程设计的目的就是要达到理论与实际应用相结合，使同学们能够根据数据对象的特性，学会数据组织的方法，能把现实世界中的实际问题在计算机内部表示出来，并培养学生的基本程序设计素养和软件工作者工作作风。

二、设计内容1.题目：模拟停车场管理问题2.问题描述：设停车场只有一个可停放几辆汽车的狭长通道，且只有一个大门可供汽车进出。

汽车在停车场按车辆到来的先后顺序依次排列，若车场内已停满几辆汽车，则后来的汽车只能在门外的便道上等候，一旦停车场内有车开走，则排在便道上的第一辆车即可进入；当停车场内某辆车要离开时，由于停车场是狭长的通道，在它之后开入的车辆必须先退出车场为它让路，待该辆车开出大门后，为它让路的车辆在按原次序进入车场。

每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。

3.基本要求：试为停车场编制按上述要求进行管理的模拟程序。

在这里假设汽车不能从便道上开走。

试设计一个停车场管理程序。

4.实现提示：以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。

用栈模拟停车场_数据结构课程设计实验报告-模拟停车场管理问题

实验二栈和队列实验报告---停车场问题

栈和队列课程设计停车场管理

停车系统实验报告

数据结构实验报告—停车场问题

数据结构停车场问题实验报告

数据结构--停车场管理-完整版-实习报告

数据结构停车场管理实验报告

数据结构-停车场管理系统实验报告

数据结构停车场问题实验报告

数据结构实验报告模拟停车场管理

数据结构用栈和队列创建停车场管理系统实验报告

停车场管理程序实验报告

数据结构实践报告--停车场管理系统

数据结构 停车场管理报告

数据结构实验报告模拟停车场管理(含代码)

数据结构课程设计实验报告-模拟停车场管理问题

数据结构课程设计--模拟停车场管理问题

数据结构停车场管理报告