数据结构停车场管理程序

合集下载

数据结构—停车场管理系统

数据结构—停车场管理系统

数据结构—停车场管理系统数据结构—停车场管理系统1.引言本文档描述了一个停车场管理系统的设计和实现。

停车场管理系统是一个用于管理停车场内车辆进出、计费等相关事务的系统。

该系统通过数据结构的应用实现了高效的车辆管理和计费功能。

2.系统概述2.1 目标停车场管理系统的目标是提供一个高效、准确和可靠的车辆管理和计费系统,使停车场管理人员能够更好地管理停车场内的车辆。

2.2 功能该系统的主要功能包括:●车辆进入管理:记录进入停车场的车辆信息,包括车牌号码、进入时间等●车辆离开管理:记录离开停车场的车辆信息,包括车牌号码、离开时间等,并计算相应的停车费用●停车位管理:记录停车场内所有车位的使用情况,包括已使用和空闲的车位信息●支付管理:根据停车时长计算停车费用,并提供支付功能●统计报表:停车场内车辆进出、停车时长、收入等相关统计报表3.系统设计3.1 数据结构选择为了实现停车场管理系统的高效运行,选择以下数据结构:●链表:用于管理车辆进出的顺序,支持快速插入和删除操作●哈希表:用于存储车辆信息,通过车牌号码作为键,快速检索和访问各个车辆的信息●栈:用于管理停车场内的车位,支持快速分配和释放车位●队列:用于统计报表时的数据存储和处理3.2 系统架构停车场管理系统的整体架构如下所示:●用户界面:提供用户操作界面,包括车辆进入、离开、支付以及查询等功能●车辆管理模块:负责处理车辆进入和离开的相关逻辑,包括记录车辆信息、计算停车费用等●停车位管理模块:负责管理停车场内车位的分配和释放,包括查找空闲车位、更新车位状态等●统计报表模块:负责停车场内各种统计报表,包括车辆进出统计、停车时长统计、收入统计等4.系统实现4.1 用户界面实现用户界面可以通过文本命令行交互或者图形用户界面来实现,具体实现方式根据实际需求决定。

4.2 车辆管理模块实现车辆管理模块可以通过链表来实现车辆进出的顺序管理。

每次车辆进入时,创建一个新的节点插入链表末尾;每次车辆离开时,从链表中删除对应节点。

数据结构课程设计——停车场

数据结构课程设计——停车场

数据结构课程设计——停车场在当今社会,随着汽车数量的不断增加,停车场的管理变得日益重要。

一个高效、合理的停车场管理系统不仅能够提高停车场的使用效率,还能为车主提供更好的服务体验。

在本次数据结构课程设计中,我们将深入探讨如何设计一个实用的停车场管理系统。

一、需求分析首先,我们需要明确停车场管理系统的基本需求。

一般来说,它应该具备以下功能:1、车辆的入场登记,包括车辆的车牌号、入场时间等信息。

2、车辆的出场结算,根据停车时间计算停车费用。

3、实时显示停车场内的车位使用情况,以便车主了解是否有空闲车位。

4、能够支持不同类型的车辆,如小型车、中型车、大型车等,并根据车辆类型收取不同的费用。

二、数据结构选择为了实现上述功能,我们需要选择合适的数据结构来存储和管理停车场的相关信息。

1、对于车辆信息的存储,我们可以使用链表。

链表的优点是插入和删除操作比较方便,可以快速地对车辆的入场和出场进行处理。

2、对于车位的管理,我们可以使用栈或者队列。

如果采用栈的方式,先进后出,适合模拟停车场的一端进出;如果采用队列的方式,先进先出,更符合一些实际场景中车辆按顺序入场和出场的情况。

3、为了快速查找车辆的信息,我们还可以使用哈希表,通过车牌号作为键,快速获取车辆的相关数据。

三、系统设计1、入场流程当车辆入场时,系统会获取车辆的车牌号、车型和入场时间等信息。

将这些信息存储到链表中,并在车位管理的数据结构(如栈或队列)中为车辆分配一个车位。

同时,更新停车场内的车位使用情况。

2、出场流程车辆出场时,根据车牌号在链表中查找车辆的入场时间等信息,计算停车时间和费用。

然后在车位管理的数据结构中释放车位,并更新车位使用情况。

3、车位显示实时统计车位管理数据结构中的空闲车位数量,并展示给车主,让他们能够提前了解停车场的空位情况。

4、费用计算根据车辆的车型和停车时间,按照预设的收费标准计算停车费用。

四、算法实现1、车辆入场算法```cvoid vehicleEntry(char plateNumber, int vehicleType) {Vehicle newVehicle =(Vehicle )malloc(sizeof(Vehicle));strcpy(newVehicle>plateNumber, plateNumber);newVehicle>vehicleType = vehicleType;newVehicle>entryTime = time(NULL);//将车辆信息插入链表insertVehicle(newVehicle);//为车辆分配车位allocateParkingSpace(newVehicle);updateParkingStatus();}```2、车辆出场算法void vehicleExit(char plateNumber) {Vehicle vehicle = searchVehicle(plateNumber);if (vehicle == NULL) {printf("未找到该车辆信息\n");return;}double parkingFee = calculateFee(vehicle);//释放车位releaseParkingSpace(vehicle);//从链表中删除车辆信息deleteVehicle(vehicle);updateParkingStatus();printf("车牌号:%s,停车费用:%2f 元\n", plateNumber, parkingFee);}```3、车位分配算法(以栈为例)void allocateParkingSpace(Vehicle vehicle) {if (top < MAX_PARKING_SPACES 1) {parkingSpaces++top = vehicle;vehicle>parkingSpaceNumber = top + 1;} else {printf("停车场已满\n");}}```4、车位释放算法```cvoid releaseParkingSpace(Vehicle vehicle) {if (top >= 0 && parkingSpacestop == vehicle) {parkingSpacestop = NULL;top;} else {printf("车位释放错误\n");}}```五、系统测试在完成系统的开发后,我们需要进行充分的测试以确保系统的稳定性和正确性。

数据结构停车场管理系统数据结构设计

数据结构停车场管理系统数据结构设计

数据结构停车场管理系统数据结构设计在智能化时代的今天,停车问题成为了城市管理的一大难题。

为了解决车辆日益增多的停车需求,设计一个高效的停车场管理系统显得尤为重要。

本文将围绕数据结构的设计来探讨停车场管理系统的实现。

一、需求分析停车场管理系统的主要功能是提供用户停车、缴费、查询等服务,同时需要为管理人员提供车辆调度、收费统计等功能。

为了实现这些功能,我们需要从需求角度对数据结构进行设计。

1. 用户管理停车场管理系统需要记录每个用户的停车信息,包括车辆信息、停车时间等。

为了高效查询用户信息,可以使用哈希表作为数据结构,将用户的身份证号或车牌号作为键值,用户信息作为值进行存储。

2. 车辆管理为了维护停车场内的车辆信息,我们可以使用链表作为数据结构来管理车辆。

每个节点可以保存一个车辆的信息,如车牌号、停车时间等,同时连接下一个车辆节点。

3. 车位管理停车场需要管理可用车位和已停车位。

为了高效分配车位,可以使用堆作为数据结构来存储可用车位信息。

堆可以根据剩余车位数量进行自动排序,当有车辆进入停车场时,从堆中取出最小的剩余车位。

4. 收费管理停车场管理系统需要计算用户停车时间并进行费用结算。

为了高效计算停车时间,可以使用栈作为数据结构来记录每个用户进入停车场的时间。

栈可以实现先进后出的特点,正好符合车辆停车的实际情况。

当用户离开停车场时,可以根据进入时间计算停车时间并进行费用结算。

5. 查询与统计为了用户能够方便地查询自己的停车信息,可以使用二叉查找树作为数据结构,将用户的车牌号作为键值进行存储。

二叉查找树可以在O(log n)的时间复杂度内完成查询操作。

另外,为了方便管理人员进行统计工作,可以使用散列表来存储车辆的停车信息,以便根据不同条件进行统计分析。

二、系统设计基于以上需求分析,我们可以得出停车场管理系统的数据结构设计如下:1. 用户管理使用哈希表来存储用户信息,将用户的身份证号或车牌号作为键值,用户信息作为值进行存储。

数据结构(C语言版)停车场管理(完美版)

数据结构(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个位置。

数据结构-停车场管理程序代码

数据结构-停车场管理程序代码

源程序代码:#include <stdio.h>#include <stdlib.h>#include <iostream.h>#include <time.h>#define MaxSize 5#define fee 2#define L 10000#define M 20000typedef int ElemType;ElemType tmpnum=0;ElemType tmptime=0;typedef struct {ElemType car_num[MaxSize];ElemType car_time[MaxSize];int top;}STACK;typedef struct qnode {ElemType car_num;ElemType car_time;struct qnode *next;}QTYPT;typedef struct qptr {QTYPT *front;QTYPT *rear;}SQUEUE;SQUEUE LQ;void InitStack(STACK *S){S->top = -1;}int Full(STACK *S){if(S->top==MaxSize-1){printf("\n Stack is full! Push");return 0;}return 1;}int Push(STACK *S,ElemType num,ElemType time){ if(S->top==MaxSize-1){printf("\n Stack is full! Push");return 0;}S->top++;S->car_num[S->top]=num;S->car_time[S->top]=time;return 1;}int Empty(STACK *S){return (S->top==-1 ? 1:0);}int Pop(STACK *S,ElemType *num,ElemType *time){if(Empty(S)){puts("Stack is free Pop");return 0;}*num=S->car_num[S->top];*time=S->car_time[S->top];S->top--;return 1;}int GetTop(STACK *S,ElemType *num,ElemType *time){ if(Empty(S)){puts("Stack is free Gettop");}*num=S->car_num[S->top];*time=S->car_time[S->top];return 1;}void InitQueue(SQUEUE *LQ){QTYPT *p=NULL;p=(QTYPT *)malloc(sizeof(QTYPT));p->next=NULL;LQ->front=LQ->rear=p;}int EnQueue(SQUEUE *LQ,ElemType num,ElemType time){ QTYPT *s;s=(QTYPT *)malloc(sizeof(QTYPT));s->car_num=num;s->car_time=time;s->next=LQ->rear->next;LQ->rear->next=s;LQ->rear=s;return 1;}int CountQueue(SQUEUE *LQ){int i=1;QTYPT *mfront=NULL;QTYPT *mrear=NULL;mfront=LQ->front;mrear=LQ->rear;while(!(LQ->front==LQ->rear)){i++;LQ->front=LQ->front->next;}LQ->front=mfront;return i;}int Empty_Q(SQUEUE *LQ){return (LQ->front==LQ->rear?1:0);}int OutQueue(SQUEUE *LQ,ElemType *num,ElemType *time){ QTYPT *p;if(Empty_Q(LQ)){puts("Quenue is free OutQuenue");return 0;}p=LQ->front->next;*num=p->car_num;*time=p->car_time;LQ->front->next=p->next;if(LQ->front->next==NULL)LQ->rear=LQ->front;free(p);return 1;}int GetHead(SQUEUE *LQ,ElemType *num,ElemType *time){ if(Empty_Q(LQ)){puts("Quenue is free GetHead");return 0;}*num=LQ->front->next->car_num;*time=LQ->front->next->car_time;return 1;}void sleep(int time){clock_t goal;goal=time*(CLOCKS_PER_SEC)+clock();while(goal > clock()){;}}int chackinput(STACK *S,int pnum){int i=0;int num;num = pnum;i=S->top;for(;!(i==-1);i--)if(S->car_num[i]==num)return 1;return 0;}int chacktime(STACK *S,int ptime){return S->car_time[S->top] <= ptime ? 1 : 0;}int displaystats(STACK *S,int pinput){void displayhead(void);int i = 0;i = S->top;switch(pinput){case 10000:{if(!Empty(S))for(;!(i==-1);i--)printf("<===%d时%d号车停与%d车位===>\n",S->car_time[i],S->car_time[i],i+1);elsecout<<"停车场为空";printf("还有车%d个位\n",MaxSize-S->top-1);break;}case 20000:{displayhead();break;}default:{return 1;}}return 0;}void displayhead(void){cout<<'\n'<<"<===============CT停车场管理系统===================>"<<endl;cout<<"<==操作说明: ******* ==>"<<endl;cout<<"<==A:停车命令 ******* ==>"<<endl;cout<<"<==D:出车命令 *** ==>"<<endl;cout<<"<==E:退出程序 *** ==>"<<endl;cout<<"<==L: 显示停车场内状况 "<<endl;cout<<"<==============================================>"<<endl;}void displayChange(STACK *S,ElemType pnum,int ptime){printf(" (单价 %d元/小时 )\n",fee);printf("<======================电子收据===================>\n");printf("<==停车时间:--------------------------%d小时==>\n",ptime-tmptime);printf("<==车牌号码:--------------------------%d==>\n",tmpnum);printf("<==应收费用:--------------------------%d 元==>\n",(ptime-tmptime)*fee);printf("<====================谢谢=欢迎下次再来=============>\n");printf("正在打印收据请稍等\n");for(int count=1; count < 1;count++){printf("=");fflush(stdout);sleep(1);}printf(">\n");sleep(1);}void wait(char *string){printf("%s\n",string);for(int count=1; count < 1;count++){printf("-");fflush(stdout);sleep(1);}printf(">\n");}int outparkstation(STACK *S1,STACK *TS,ElemType pnum){int t_num=0;int t_time=0;while(1){Pop(S1,&t_num,&t_time);if(t_num == pnum){tmpnum=t_num;tmptime=t_time;while(!Empty(TS)){Pop(TS,&t_num,&t_time);Push(S1,t_num,t_time);}return 1;}Push(TS,t_num,t_time);}return 0;}int inparkstation(STACK *S){int parknum;int parktime;printf("还有车%d个位\n",MaxSize-S->top-1);printf("请输入车牌号码:");cin>>parknum;while(chackinput(S,parknum)){ printf("车牌号码重复,请输入%d1或者其他",parknum);cin>>parknum;}printf("请输入停车时间:");cin>>parktime;printf("%d号车于%d时停靠在%d位\n",parknum,parktime,S->top+2);Push(S,parknum,parktime);return 1;}int inbiandao(SQUEUE *SQ,STACK *S){int parknum ;printf("对不起,停车场已满,请您到便道等待.您将第");printf("%d进入停车场\n",CountQueue(SQ));printf("请输入车牌号码:");cin>>parknum;while(chackinput(S,parknum)) { printf("车牌号码重复,请输入%d1或者其他",parknum);cin>>parknum;} EnQueue(SQ,parknum,0);return 1;}int OutParkingStation(SQUEUE *biandao,STACK *car,STACK *tmp){int parknum = 0;int parktime = 0;int buf=0;if(!Empty(car)){displaystats(car,10000);printf("请输入您要调出的车牌号码:");cin>>parknum;while(!chackinput(car,parknum)) { printf("没有您要的%d的车牌号码,请输入正确的车牌号码:",parknum);cin>>parknum;} outparkstation(car,tmp,parknum); printf("%d时%d号车进入停车场\n",tmptime,tmpnum);printf("请输入现在的时间:");cin>>parktime;while(!chacktime(car,parktime)) { cout<<"输入时间小于停车时间,请重新输入:";cin>>parktime; }displayChange(car,parknum,parktime); if(biandao->front==biandao->rear) { }else{ printf("%d号车位空开\n",car->top+2);printf("%d时便道上的%d号汽车驶入%d号车位",parktime,biandao->front->next->car_num,car->top+2);OutQueue(biandao,&parknum,&buf); Push(car,parknum,parktime); }return 2;}printf("停车场为空\n"); return 1; };int main(int argc,char* agv[]){char chance='A';STACK car;InitStack(&car);STACK tmp;InitStack(&tmp);SQUEUE biandao;InitQueue(&biandao);loop:while(1){displayhead();cout<<"=>:";cin>>chance;switch(chance) {case 'A':{wait("正在查询车位,请稍等:");if(Full(&car))inparkstation(&car);elseinbiandao(&biandao,&car);break;}case 'D':{OutParkingStation(&biandao,&car,&tmp);break;}case 'L':{displaystats(&car,10000);break;}case 'M':{displaystats(&car,20000);break;}case 'E':{wait("正在保存数据程序即将退出\n命令执行中:"); exit(0);}default:{cout<<"输入错误"<<endl;goto loop;}}}system("PAUSE");return 0;}。

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

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

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

二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 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 <<"停车场内没有车辆。

数据结构设计-停车场管理系统

数据结构设计-停车场管理系统

数据结构设计-停车场管理系统数据结构设计停车场管理系统在现代社会,随着汽车数量的不断增加,停车场的管理变得日益重要。

一个高效、准确且便捷的停车场管理系统对于提高停车场的运营效率、提升用户体验以及保障停车场的安全都具有重要意义。

而在实现这样一个系统的过程中,数据结构的设计起着关键的作用。

首先,让我们来明确一下停车场管理系统的基本需求。

它需要能够记录车辆的进入和离开时间,计算停车费用,管理车位的占用和空闲状态,提供车位的查询和预订功能,以及处理异常情况,如超时未缴费等。

为了满足这些需求,我们需要选择合适的数据结构来存储和操作相关的数据。

对于车辆信息的存储,我们可以使用一个链表或者数组来实现。

每个车辆的信息可以包括车牌号码、进入时间、预计离开时间、实际离开时间、停车费用等。

链表的优点是插入和删除操作比较方便,适合车辆频繁进出的情况;而数组则在随机访问方面具有优势,可以快速获取特定车辆的信息。

车位的管理是停车场系统的核心部分之一。

我们可以将停车场看作一个二维的矩阵,每个位置表示一个车位。

使用一个布尔型的二维数组来表示车位的占用状态,True 表示占用,False 表示空闲。

这样,在查询空闲车位时,只需要遍历这个数组即可。

为了提高查询效率,我们还可以对车位进行分区,比如按照楼层、区域等划分,然后分别管理每个分区的车位状态。

在计算停车费用时,需要根据车辆的停车时间来确定。

可以使用时间戳来记录车辆的进入和离开时间,然后通过计算时间差来得到停车时长。

停车费用的计算规则可以根据不同的时间段设置不同的费率,例如,白天和晚上的费率可能不同,周末和工作日的费率也可能有所差异。

为了实现车位的预订功能,我们可以使用一个优先级队列或者堆来管理预订请求。

预订请求包含预订时间、预计停车时长等信息。

根据预订时间和预计停车时长,可以对预订请求进行排序,优先处理先到的请求。

当车辆进入停车场时,系统首先查询空闲车位,如果有空闲车位,则记录车辆信息,并更新车位状态。

数据结构—停车场管理系统

数据结构—停车场管理系统

数据结构—停车场管理系统数据结构—停车场管理系统1:引言该文档旨在描述停车场管理系统的数据结构,详细介绍了系统的各个模块和数据的组织方式,帮助开发人员深入理解系统的结构和实现方式。

2:系统概述停车场管理系统是一种用于管理停车场的软件系统。

它可以跟踪和管理车辆的进入和离开,并提供数据分析和报告功能。

3:系统架构3.1 模块1:用户管理3.1.1 注册用户3.1.2 登录功能3.1.3 用户权限管理3.2 模块2:停车场管理3.2.1 停车位管理3.2.1.1 增加停车位3.2.1.2 删除停车位 3.2.2 车辆管理3.2.2.1 车辆入场 3.2.2.2 车辆离场 3.2.3 计费管理3.2.3.1 定价策略 3.2.3.2 车辆计费3.3 模块3:数据分析3.3.1 车辆进出统计3.3.2 收入统计3.3.3 时间段分析4:数据结构4.1 用户信息4.1.1 用户ID4.1.2 用户名4.1.3 密码4.1.4 权限4.2 停车位信息4.2.1 停车位ID4.2.2 车位类型4.2.3 是否占用4.3 车辆信息4.3.1 车牌号4.3.2 车辆类型4.3.3 入场时间4.3.4 离场时间4.4 计费信息4.4.1 车辆ID4.4.2 入场时间4.4.3 离场时间4.4.4 价格5:系统流程5.1 用户注册和登录流程 5.1.1 用户注册5.1.2 用户登录认证5.2 车辆进出流程5.2.1 车辆入场5.2.2 车辆离场5.2.3 计费过程6:附件本文档附带以下文件:7:法律名词及注释- 用户信息:指用户在系统中注册和登录时提供的个人信息。

- 停车位信息:指停车场中每个停车位的相关信息,包括唯一标识、类型和占用情况等。

- 车辆信息:指进入停车场的车辆的相关信息,包括车牌号、类型和进出时间等。

- 计费信息:指车辆停留时间和计费价格等相关信息。

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

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

数据结构实验报告模拟停车场管理实验目的:通过模拟停车场管理的过程,理解数据结构的应用和实际工程问题的解决思路。

实验内容:1.设计停车场类和车辆类,并实现相关操作方法。

2.模拟停车场管理的过程,包括车辆的进入和离开。

3.根据实际需求设计停车场管理算法,如何选择停车位和调度车辆等。

实验步骤:1.设计停车场类停车场类需要保存停车位的信息,可以使用数组或链表实现。

需要提供以下方法:- void addCar(Car car):将车辆添加到停车场,如果停车场已满,则禁止入场。

- void removeCar(Car car):将车辆从停车场移除,并更新停车位信息。

- int getAvailableSpaces(:返回停车场中当前可用的停车位数量。

2.设计车辆类车辆类需要保存车辆的信息,如车牌号、车型等。

3.实现停车场管理算法停车场管理需要考虑车辆进入和离开的顺序,以及停车位的选择等问题。

可以使用队列或堆栈等数据结构来保存车辆的进出顺序。

停车位的选择可以根据具体算法进行,如先到先得、最近最便等原则。

4.完成模拟停车场管理过程的代码根据实际需求,编写代码模拟车辆进入和离开停车场的过程。

可以通过输入车辆信息和操作指令来模拟。

5.测试与优化对停车场管理算法进行测试,并根据实际情况进行优化。

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

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

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

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

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

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

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

停车场管理系统(数据结构课程设计)

停车场管理系统(数据结构课程设计)

停车场管理系统一编程思想:将停车场设计成一个虚拟的栈,将其入口设计成栈顶,在设计一个倒车场,也将其设计成一个虚拟的栈,使其入口为栈顶,再根据队列设计一个供车来停放的便道,当停车场里的车辆不为满时,车辆进入停车场,当停车场里的车辆为满时,车辆在便道里等候,当车辆从停车场里出来的时候,如果出来的不是第一个车辆,则其前面的车辆将进入倒车场里面,待车辆出去后,倒车场里的车再依次进入停车场,如果停车场不满的话,便道里等候的第一辆车进入停车场,进入停车场的时间为停车场中车辆出来的时间,再设计一个函数用来显示停车场以及便道中车辆的信息。

二程序流程图:三,程序代码:#include<stdio.h>#define Size 3 /*车库容量*/#define Price 5 /*单位价格*/#define Null 0typedef struct time{int hour; /*时间结点*/}Time;typedef struct{int car_number;Time arrivetime,leavetime; /*车信息结点*/ int fee;}car_info;typedef struct{car_info *north;car_info *south; /*停车场信息*/int number;}car_park;typedef struct{car_info *west;car_info *east; /*倒车场信息*/int number;}car_park_back;Typedef struct car{car_info *data;struct car *next; /*结点信息*/}carnode;typedef struct node{carnode *head;carnode *rear; /*便道信息*/int number;}car_park_temp;void init_car_park(car_park *cp){cp->north=(car_info *)malloc(Size * sizeof(car_info)); /*初始化停车场*/ if(!cp->north) printf("error\n");cp->south=cp->north; /*令栈顶等于栈底*/cp->number=0;}void enter_car_park(car_park *cp,car_info *car){*cp->south++=*car; /*车辆进入停车场*/cp->number++;}int notfull_car_park(car_park *cp){int e;if(cp->south-cp->north>=Size) /*判断常常是否已满*/e=0;elsee=1;return(e);int notempty_car_park_back(car_park_back *cpb){int e;if(cpb->east==cpb->west)e=0; /*判断倒车场是否不空*/ elsee=1;return(e);}void back_car_park(car_park *cp,car_info *car){*car=*cp->south; /*进行倒车操作*/cp->number--;}void init_car_park_back(car_park_back *cpb){cpb->west=(car_info *)malloc(Size *sizeof(car_info));if(!cpb->west) printf("error\n"); /*倒车场初始化*/cpb->east=cpb->west;cpb->number=0;}void enter_car_park_back(car_park_back *cpb,car_info *car) {*cpb->east++=*car;cpb->number++; /*进入倒车场操作*/}void leave_car_park_back(car_park_back *cpb,car_info *car) {*car=*--cpb->east;cpb->number--; /*离开倒车场操作*/void init_car_park_temp(car_park_temp *cpt){cpt->head=cpt->rear=(carnode *)malloc(sizeof(carnode)); /*初始化便道*/ cpt->head->next=Null;cpt->number=0;}void enter_car_park_temp(car_park_temp *cpt,car_info *car){carnode *p;p=(carnode *)malloc(sizeof(carnode)); /*进入便道操作*/p->data=car;p->next=Null;cpt->rear->next=p;cpt->rear=p;cpt->number++;}void leave_car_park_temp(car_park_temp *cpt,car_info *car,car_park *cp) {carnode *p;p=cpt->head->next;car=p->data; /*离开便道操作*/cpt->head->next=p->next;enter_car_park(cp, car); /*进入停车场操作*/cpt->number--;}int notempty_car_park_temp(car_park_temp *cpt){int e;if(cpt->head==cpt->rear) /*判断便道是否为空*/e=0;elsee=1;return(e);}void leave_car_park(car_park *cp,car_info *car,car_park_back *cpb){int e, a1,b1,t; /*定义时间变量*/car_info *car1,*car2;car1=(car_info *)malloc(sizeof(car_info)); /*车辆实体化*/car2=(car_info *)malloc(sizeof(car_info));while((--cp->south)->car_number!=car->car_number) /*判断车号是否为要出去的车号*/ {back_car_park(cp,car1); /*进行倒车操作*/enter_car_park_back(cpb,car1); /*进入倒车场*/}car->arrivetime.hour=cp->south->arrivetime.hour;a1=car->arrivetime.hour;b1=car->leavetime.hour;t=(b1-a1);car->fee=t*Price; /*计算价格*/printf("the time of the car is %3d hour\n",t);printf("the money is %3d yuan\n",car->fee);e=notempty_car_park_back(cpb); /*判断倒车场是否为空*/while(e==1){leave_car_park_back(cpb,car2); /*离开倒车场enter_car_park(cp,car2); 进入停车场e=notempty_car_park_back(cpb); 判断倒车场是否为空*/}cp->number--;}void main() /*主函数*/{char ch; /*定义字符和int e,n,i; 整形变量*/car_park_back *cpb; /* 定义停车场,倒车场以及便道的变量*/ car_park *cp;car_park_temp *cpt,*cpt2;car_info *car;cp=(car_park *)malloc(sizeof(car_park)); /*实体化变量*/cpb=(car_park_back *)malloc(sizeof(car_park));cpt=(car_park_temp *)malloc(sizeof(car_park_temp));init_car_park(cp); /*实体化停车场,倒车场,便道*/init_car_park_back(cpb);init_car_park_temp(cpt);do{car=(car_info *)malloc(sizeof(car_info));printf("\ninput the 'A' or 'L' or 'X' ,end with '0' :");/*输入待操作的命令*/ scanf("%s",&ch);e=notfull_car_park(cp); /*判断车场是否为空*/switch(ch) /*判断要输入的命令*/{case 'A':if(e==1) /*车场不满,进入车辆*/{printf("input the car_number:"); /*输入车辆的基本信息*/scanf("%d",&car->car_number);printf("input the arrivetime:");scanf("%d",&(*car).arrivetime.hour);enter_car_park(cp,car); /*进入车场*/printf("the car is in the car_park,the place is %d\n",cp->number);}else /*若车场满,进入便道*/{enter_car_park_temp(cpt,car);printf("input the car_number:");scanf("%d",&car->car_number);printf("the car is in the car_park_temp,the place of temp is %d\n",cpt->number);}break;case 'L': /*离开停车场*/printf("input the car_number:"); /*输入要离开车辆的号码以及离开时间*/scanf("%d",&car->car_number);printf("input the leavetime of the car:");scanf("%d",&(*car).leavetime.hour);leave_car_park(cp,car,cpb); /*执行离开车场*/i=(*car).leavetime.hour; /*令便道里车辆进入车场的时间和车场里面的车离开的时间相等*/n=notempty_car_park_temp(cpt); /*判断便道是否不空*/if(n==1)printf("The car %d",cpt->head->next->data->car_number); /*记住便道里第一辆车的号码*/ leave_car_park_temp(cpt,car,cp); /*离开便道,进入停车场*/printf(" is enter the car_park,arrivetime is %d ,the place of carpark is %d\n",i,cp->number);break;case 'X': /*查看车场以及便道里的车辆信息*/printf("\nThere are %d cars in car park!\nFolowing is the carnumber in the car park:\n ",cp->number);for(i=1;i<=cp->number;i++) /*做循环,依次输出停车场里车辆的信息*/printf("%d,",(cp->north++)->car_number);cp->north=cp->north-cp->number;cpt2->head=cpt->head; /*设一个虚拟指针使其指向头结点的下一个位置*/ if(cpt->number==0) /*便道里没有车的情况*/printf("\nThere is no cars in temp!") ;else{ printf("\nThere are %d cars in car temp!\nFolowing is the carnumber in the car temp:\n ",cpt->number);for(i=1;i<=cpt->number;i++) /*做一个循环,输出便道里车辆的信息*/ {printf("%d ",cpt2->head->next->data->car_number); /* 输出车辆的号码*/ cpt2->head=cpt2->head->next;}}break;default:break; /*退出循环*/}}while(ch!='0'); /*退出操作*/}。

数据结构 停车场管理系统

数据结构 停车场管理系统

数据结构停车场管理系统停车场管理系统范本1. 系统概述1.1 系统介绍1.2 目标与目的2. 功能需求2.1 用户注册与登录2.2 车辆入场管理2.2.1 车辆信息录入2.2.2 车辆类型判断2.2.3 分配停车位2.3 车辆出场管理2.3.1 判断车辆是否支付停车费用2.3.2 更新车辆状态2.3.3 计算停车费用2.4 停车场运营统计2.4.1 车位统计2.4.2 收入统计2.4.3 车流量统计2.5 系统管理2.5.1 用户权限管理2.5.2 数据备份与恢复3. 性能需求3.1 响应时间要求3.2 并发用户数要求3.3 数据存储容量要求4. 系统架构4.1 技术选型4.2 系统组成部分4.2.1 前端界面4.2.2 后端服务4.2.3 数据库5. 数据结构设计5.1 用户数据结构5.2 车辆数据结构5.3 停车位数据结构5.4 订单数据结构5.5 统计数据结构6. 数据库设计6.1 用户表设计6.2 车辆表设计6.3 停车位表设计6.4 订单表设计6.5 统计表设计7. 界面设计7.1 用户注册与登录界面 7.2 车辆入场界面7.3 车辆出场界面7.4 停车场运营统计界面 7.5 系统管理界面8. 系统测试8.1 单元测试8.2 集成测试8.3 系统测试9. 系统部署与运维9.1 硬件环境配置9.2 软件环境配置9.3 数据库部署与备份9.4 系统监控与维护附件:无法律名词及注释:1. 用户注册与登录:指用户在系统中注册账号并登录使用系统的过程。

2. 车辆入场管理:指车辆进入停车场并进行相应管理的过程,包括信息录入、分配停车位等操作。

3. 车辆出场管理:指车辆离开停车场并进行相应管理的过程,包括支付停车费用、更新车辆状态、计算停车费用等操作。

4. 停车场运营统计:指对停车场运营情况进行统计与分析的过程,包括车位统计、收入统计、车流量统计等内容。

5. 系统管理:指对系统运行和功能进行管理的过程,包括用户权限管理、数据备份与恢复等操作。

数据结构设计报告停车场管理系统方案

数据结构设计报告停车场管理系统方案

数据结构设计报告停车场管理系统方案数据结构设计报告:停车场管理系统方案一、引言随着汽车数量的不断增加,停车场管理成为了一个重要的问题。

一个高效、准确、便捷的停车场管理系统对于提高停车场的运营效率、服务质量以及用户体验都具有重要意义。

本报告将详细介绍一种停车场管理系统的数据结构设计方案,旨在为相关开发人员提供参考。

二、需求分析(一)基本功能需求1、车辆的入场登记,包括车辆信息、入场时间等。

2、车辆的出场结算,根据停车时间计算费用。

3、车位的实时监控,显示空闲车位数量和位置。

4、数据的存储和查询,如车辆历史停车记录等。

(二)性能需求1、系统响应迅速,车辆入场和出场操作能够在短时间内完成。

2、数据的准确性和完整性,确保停车信息不丢失、不错误。

(三)用户需求1、为停车场管理人员提供简洁、直观的操作界面。

2、为车主提供清晰的停车引导和费用信息。

三、数据结构设计(一)车辆信息结构体```ctypedef struct {char licensePlate20; //车牌号time_t entryTime; //入场时间time_t exitTime; //出场时间float parkingFee; //停车费用} Vehicle;```(二)车位信息结构体```ctypedef struct {int parkingSpaceNumber; //车位编号int status; // 0:空闲 1:占用} ParkingSpace;```(三)停车场结构体```ctypedef struct {ParkingSpace parkingSpaces; //车位数组int totalSpaces; //总车位数Vehicle vehicles; //车辆数组int totalVehicles; //车辆总数} ParkingLot;```(四)数据存储1、使用文件存储停车场的基本信息,如总车位数等。

2、使用数据库存储车辆的停车记录,便于查询和统计。

C语言停车场管理器程序_数据结构课程设计

C语言停车场管理器程序_数据结构课程设计

做完了课程设计,用C语言写的。

不过挑了个容易点的,停车场管理系统。

不过写得好繁琐啊,好耐无用C语言了。

请大家指教,也帮帮急需的朋友们。

呵呵···终于可以放假啦,嘿嘿·····/*******************************停车场管理器*************************************/#include<stdio.h>#include<stdlib.h>#include<string.h>#include <conio.h>/********************************************************************************/#define MAXSTACKSIZE 2 /*车库容量*/#define price 0.1 /*每车每分钟费用*/typedef struct time{int hour;int min;}Time; /*时间结点*/typedef struct {char num[10];Time reach;Time leave;}CarNode; /*车辆信息结点*/typedef struct {CarNode *base;CarNode *top;int stacksize;}SqStackCar; /*模拟车站*/typedef struct car{CarNode *data;struct car *next;}QueueNode;typedef struct {QueueNode *front;QueueNode *rear;}LinkQueueCar; /*模拟通道*/int QueueEmpty(LinkQueueCar Q) /*便道判空函数*/{if(Q.front==Q.rear) return 1;else return 0;}/********************************************************************************/ void InitStack(SqStackCar *s) /*初始化栈*/{s->base=(CarNode *)malloc(MAXSTACKSIZE*sizeof(CarNode));if(!s->base) exit(0);/*分配失败*/s->top=s->base;s->stacksize=MAXSTACKSIZE;}int Push(SqStackCar *s,CarNode *e) /*进站函数*/{if(s->top-s->base>=s->stacksize) return 0;else *s->top++=*e;return 1;}int Pop(SqStackCar *s,CarNode *e) /*出站函数*/{if(s->top==s->base) return 0;*e=*--s->top;return 1;}int StackEmpty(SqStackCar s) /*判空函数*/{if(s.base==s.top) return 1;else return 0;}int InitQueue(LinkQueueCar *Q) /*初始化便道*/{Q->front=Q->rear=(QueueNode *)malloc(sizeof(QueueNode));if(!Q->front) exit(0);Q->front->next=NULL;return 1;}/**************************************************************/ int EnQueue(LinkQueueCar *Q,CarNode *e) /*便道插入函数*/{QueueNode *p;p=(QueueNode *)malloc(sizeof(QueueNode));if(!p) exit(0);p->data=e;p->next=NULL;Q->rear->next=p;Q->rear=p;return 1;}int DeQueue(LinkQueueCar *Q,CarNode *e) /*便道删除函数*/{QueueNode *p;if(Q->front==Q->rear) return 0;p=Q->front->next;e=p->data;Q->front->next=p->next;if(Q->rear==p) Q->rear=Q->front;free(p);return 1;}/********************************************************************************/ int Arrive(SqStackCar *In,LinkQueueCar *Wait) /*车辆到达函数*/{CarNode *i;QueueNode *w;i=(CarNode *)malloc(sizeof(CarNode));flushall();printf("Input the car number:");gets(i->num);if(In->top-In->base<MAXSTACKSIZE) /*车场未满,车辆进栈*/{printf("\nThe time the car arrive(00:00): ");scanf("%d:%d",&i->reach.hour,&i->reach.min);Push(In,i);printf("\nCar in success!!");sleep(1);return 1;}else /*停车场已满,车进便道*/{w=(QueueNode *)malloc(sizeof(QueueNode));w->data=i;w->next=NULL;Wait->rear->next=w;printf("The PART is full,car must wait in the road!");sleep(1);return 1;}return 0;}/********************************************************************************/ int Departure(SqStackCar *In,SqStackCar *temp,LinkQueueCar *Wait) /*车辆离开函数*/{int flag=0,a1,a2,b1,b2, money;CarNode *p,*t;QueueNode *q;p=(CarNode *)malloc(sizeof(CarNode));flushall();printf("Input the out car number: ");gets(p->num);while(!StackEmpty(*In)){t=(CarNode *)malloc(sizeof(CarNode));Pop(In,t);if(strcmp(p->num,t->num)==0) /*比较车场中有无这辆车,有即出站*/{printf("Input the time the car out(00:00):");scanf("%d:%d",&p->leave.hour,&p->leave.min);printf("The ");printf("%s",p->num);printf(" Car out the part!");a1= p->leave.hour;a2= t->reach.hour;b2= t->reach.min;money = ((a1-a2+24)%24*60+(b1-b2+60)%60)*price; /*计算车辆需要的费用*/printf("\nThe time the car arrive: %d:%d",t->reach.hour,t->reach.min);printf("\nThe time the car leave: %d:%d",p->leave.hour,p->leave.min);printf("\nNeed: %d yuan",money);flag=1;getch();free(t);break;}elsePush(temp,t);} /*while*/if(!flag){printf("No this car!!");getch();}while(!StackEmpty(*temp)){Pop(temp,p);Push(In,p);}free(p);if(flag&&Wait->front!=Wait->rear) /*车站中有空位,便道有车,车入站*/ {q=(QueueNode *)malloc(sizeof(QueueNode));q=Wait->front->next;t=q->data;if(q!=NULL){Push(In,t);printf("\nThe ");printf("%s",t->num);printf(" car in part!");printf("\nInput the time the car arrive(00:00): ");scanf("%d:%d",&t->reach.hour,&t->leave.min);}Wait->front->next=q->next;if(q==Wait->rear) Wait->rear=Wait->front;free(q);}return 1;}/****************************************************************************** **/void Print(SqStackCar *In,SqStackCar *Temp,LinkQueueCar *Wait) /*打印函数*/{int c=0;int count=1;CarNode *p,*t;QueueNode *q;q=(QueueNode *)malloc(sizeof(QueueNode));p=(CarNode *)malloc(sizeof(CarNode));t=(CarNode *)malloc(sizeof(CarNode));while(1&&c!='3'){clrscr();gotoxy(1,10);printf("1. Print the road!");gotoxy(1,11);printf("2. Print the part!");gotoxy(1,12);printf("3. return.");do{printf("\nInput your choice:");c = getche();printf("\n");}while(c!='1'&&c!='2'&&c!='3');if(c=='2') /*打印停车场*/{printf("The car in the part!\n");count=1;while(!StackEmpty(*In)){Pop(In,t);}while(!StackEmpty(*Temp)){Pop(Temp,t);printf("The ");printf("%d",count);printf(" car number is: ");count++;puts(t->num);Push(In,t);}printf("Press any key to continue...");getch();}if(c=='1') /*打印便道*/{printf("The car in the road!\n");count=1;q=Wait->front->next;if(Wait->front!=Wait->rear) /**/{while(q!=NULL){p=q->data;printf("The ");printf("%d",count);printf(" Car number is: ");puts(p->num);count++;}}else printf("\nNo car in the road.");printf("Press any key to continue...");getch();}}}/***************************主程序***********************************************/ int Arrive(SqStackCar *In,LinkQueueCar *Wait);int Departure(SqStackCar *In,SqStackCar *temp,LinkQueueCar *Wait);void Print(SqStackCar *In,SqStackCar *temp,LinkQueueCar *Wait);void initialization();char readcommand();void interpret(char cmd);main(){char cmd;SqStackCar part,temp;LinkQueueCar road;InitStack(&part);InitStack(&temp);InitQueue(&road);printf("Press any key to continue......");getch();while(1){initialization(); /*初始化界面*/cmd = readcommand(); /*读取停车场状况*/clrscr();switch(cmd){case 'a': Arrive(&part,&road); break;case 'A': Arrive(&part,&road); break;case 'd': Departure(&part,&temp,&road); break;case 'D': Departure(&part,&temp,&road); break;case 'p': Print(&part,&temp,&road); break;case 'P': Print(&part,&temp,&road); break;case 'e': printf("Press any to continue...");getch();exit(0); break;case 'E': printf("Press any to continue...");getch();exit(0); break;default : printf("ERROR!"); break;}}}/********************************************************************************/ void initialization() /*初始函数*/{int i;clrscr();gotoxy(0,0);for(i=1;i<=240;i++)printf("\1");gotoxy(15,8);printf("THIS IS A CAR PART MANAGE SYSYTEM!");gotoxy(15,12);printf("NAME: LIYONGJUN.");gotoxy(15,13);printf("NUM: 3104006893.");;.. gotoxy(15,14);printf("GRADE: 2004.");gotoxy(15,15);printf("CLASS: COMPUTER SCIENCE AND TECHNOLOGY 10"); gotoxy(1,20);printf("\n********************************************************************************");printf("1. Car Arrive--A 2. Car Departure--D 3. Print Car--P 4.Exit--E");printf("\n********************************************************************************");printf("Input C,D,P,E choose!!\n");}char readcommand() /*选择函数*/{char cmd;do{printf("Input your choice:");cmd = getche();printf("\n");}while((cmd!='a')&&(cmd!='A')&&(cmd!='d')&&(cmd!='D')&&(cmd!='p')&&(cmd!='P')&&(cmd!='E')&&( cmd!='e'));return cmd;}。

数据结构—停车场管理系统

数据结构—停车场管理系统

数据结构—停车场管理系统停车场管理系统【⒈系统介绍】本章主要介绍停车场管理系统的背景和目的,包括系统的功能和应用场景等。

【⒉系统需求】本章详细描述停车场管理系统的功能性需求和非功能性需求,包括系统的基本功能、用户需求、安全性要求、性能要求等。

【⒊系统架构设计】本章介绍停车场管理系统的架构设计,包括系统的分层架构、模块划分、数据流程等。

【⒋数据结构设计】本章详细描述停车场管理系统使用的数据结构,包括停车场信息、车辆信息、停车记录等。

【⒌模块设计】本章详细描述停车场管理系统的各个模块的设计,包括用户管理模块、车辆管理模块、停车管理模块、费用管理模块等。

本章描述停车场管理系统的各个模块之间的接口设计,包括接口的参数、返回值、数据格式等。

【⒎数据库设计】本章详细描述停车场管理系统的数据库设计,包括数据库表结构、表之间的关系、索引设计等。

【⒏系统测试】本章描述停车场管理系统的测试计划和测试方法,包括功能测试、性能测试、安全测试等。

【⒐系统部署】本章描述停车场管理系统的部署方案,包括硬件环境要求、软件环境要求、安装步骤等。

【⒑系统维护】本章描述停车场管理系统的维护计划和维护方法,包括故障排除、数据备份、系统升级等。

【1⒈用户指南】本章提供给用户使用停车场管理系统的指南,包括用户注册、登录、车辆入场、支付退款等操作说明。

本章介绍停车场管理系统的安全性保障措施,包括数据加密、访问控制、日志监控等。

【1⒊性能优化】本章介绍停车场管理系统的性能优化方案,包括数据库优化、代码优化、服务器优化等。

【附件】⒈停车场管理系统原型设计图⒉停车场管理系统数据库表结构定义文件⒊停车场管理系统测试用例【法律名词及注释】⒈法律名词1:注释1(解释)⒉法律名词2:注释2(解释)(以下类似)。

C++数据结构停车场管理

C++数据结构停车场管理

C++数据结构停车场管理一、引言本文档旨在介绍C++数据结构停车场管理系统的设计和实现过程。

停车场管理系统是一个用于管理停车场车辆进出、计费等相关功能的软件,可以提高停车场管理的效率和精确度。

二、需求分析⒈功能需求⑴车辆入场管理:记录车辆的入场时间、车牌号等信息。

⑵车辆出场管理:根据车牌号查询车辆的停车时间并计费,同时将车辆从停车场中移除。

⑶停车位管理:实时显示停车场内还有多少空闲停车位。

⑷支付管理:提供支付功能,支持现金、信用卡等多种支付方式。

⑸数据统计:停车场的使用统计报表,包括停车次数、收入等信息。

⒉性能需求⑴系统响应时间应尽可能短,以满足用户快速进出停车场的需求。

⑵数据存储和查询速度应尽可能快,以保证系统的实时性和准确性。

三、系统设计⒈数据结构设计⑴车辆信息:使用结构体保存车辆的信息,包括车牌号、入场时间、离场时间等。

⑵停车位状态:使用数组或链表表示停车位的状态,空闲或占用。

⑶支付记录:使用结构体保存支付的相关信息,包括支付方式、支付时间等。

⒉模块设计⑴车辆入场管理模块:负责记录车辆的入场时间和车牌号,并将车辆信息添加到停车场管理系统中。

⑵车辆出场管理模块:接受用户输入车牌号查询车辆的停车时间并计费,同时将车辆从停车场中移除。

⑶停车位管理模块:实时更新停车位的状态,显示停车场内还有多少空闲停车位。

⑷支付管理模块:提供支付功能,支持现金、信用卡等多种支付方式。

⑸数据统计模块:停车场的使用统计报表,包括停车次数、收入等信息。

四、系统实现⒈系统流程图插入系统流程图⒉模块实现略\t五、测试与验证⒈单元测试:对每个模块进行独立测试,确保其功能的正确性和稳定性。

⒉集成测试:将所有模块整合在一起进行测试,验证系统的功能和性能是否符合需求。

六、部署与维护⒈部署:将停车场管理系统部署到指定的服务器或计算机上,配置相关的数据库和网络连接。

⒉维护:定期检查系统的稳定性和性能表现,及时修复错误和进行系统更新。

七、文档附件本文档涉及附件,请参考附件部分。

数据结构停车场管理

数据结构停车场管理

数据结构停车场管理简介停车场管理是一项涵盖车辆进出、停放、缴费等多方面功能的系统。

为了实现停车场的高效管理,需要运用数据结构来进行实现。

在本文中,我们将介绍如何利用数据结构来实现停车场管理系统。

数据结构的应用停车场有许多可管理的事情,例如停车场的空余车位数、车辆的进出、缴费等等。

在这些功能中,有一些需要我们使用数据结构来简化实现和提高效率。

队列停车场的管理需要使用队列这种数据结构。

当一个车辆要停入停车场时,需要将它按照到达的时间先后排序,按顺序排队等待停车。

而车辆离开停车场时,则需要先进先出,也就是先离开停车场的车辆需要先交费,后离开。

这一过程需要用到队列。

栈在停车场管理中,可用栈来实现车辆的进出。

车辆在进入停车场时,需要将车辆的信息保存。

而在车辆离开停车场时,则需要将对应的信息出栈并完成缴费后,才能让车辆离开。

这一过程需要用到栈。

链表停车场的剩余车位数是一个变化的过程。

在每有一辆车进入停车场或者有一辆车辆离开停车场时,都要对剩余车位数做出相应的更改。

这一过程中,可以用链表来实现。

只需要将每一辆车对应的链表节点记录进来,每进入一辆车就将一个节点从链表中删除,每辆车离开停车场则将一个节点加入链表。

数据结构的具体应用现在我们将来看看停车场管理中具体的应用。

进入停车场当一辆车进入停车场时,需要执行以下操作:1.首先,要判断停车场是否已经满了。

若停车场已满,则无法允许车辆进入停车场。

2.若停车场未满,则需要将这辆车的信息加入栈中,用于管理和监测。

3.同时,还需要将这辆车按到达的时间加入到队列中,便于后续的管理。

4.最后,还需要更新停车场的剩余车位数,并将结果写入数据库中。

离开停车场当一辆车在完成缴费后离开停车场时,需要执行以下操作:1.首先,需要从栈中出栈,将车辆的信息拿出来。

2.然后,需要将这辆车从队列中删除,避免干扰后续车辆的出场。

3.接着,需要更新停车场的剩余车位数,将车位数加一,并将结果写入数据库中。

数据结构c语言版课程设计停车场管理系统

数据结构c语言版课程设计停车场管理系统

课程设计:停车场c语言版本的数据结构课程设计,规定用栈模拟停车场,用队列模拟便道,实现停车场的收费管理系统停车场停满车后车会停在便道上面下面附上源码,vc:(下编译#include <stdio.h>//#include <stdlib.h> //malloc#include <time.h> //获取系统时间所用函数#include <conio.h> //getch()#include <windows.h> //设立光标信息mallco#define MaxSize 5 /*定义停车场栈长度*/#define PRICE 0.05 /*每车每分钟收费值*/#define BASEPRICE 0.5 //基础停车费#define Esc 27 //退出系统#define Exit 3 //结束对话#define Stop 1 //停车#define Drive 2 //取车int jx=0,jy=32; //全局变量日记打印位置typedef struct{int hour;int minute;}Time,*PTime; /*时间结点*/typedef struct /*定义栈元素的类型即车辆信息结点*/ {int num ; /*车牌号*/Time arrtime; /*到达时刻或离区时刻*/}CarNode;typedef struct /*定义栈,模拟停车场*/{CarNode stack[MaxSize];int top;}SqStackCar;typedef struct node /*定义队列结点的类型*/{int num; /*车牌号*/struct node *next;}QueueNode;typedef struct /*定义队列,模拟便道*/{QueueNode *front,*rear;}LinkQueueCar;/*函数声明*/PTime get_time();CarNode getcarInfo();void qingping(int a);void gotoxy(int x,int y);void printlog(Time t,int n,int io,char ab,int po,double f);void printstop(int a,int num,int x0,int y0);void printleave(int a,int po,int num);/*初始化栈*/void InitSeqStack(SqStackCar *s){s->top=-1;}/* push入站函数*/int push(SqStackCar *s,CarNode x) //数据元素x入指针s所指的栈{if(s->top==MaxSize-1)return(0); //假如栈满,返回0 else{s->stack[++s->top]=x; //栈不满,到达车辆入栈return(1);}}/*栈顶元素出栈*/CarNode pop(SqStackCar *s){CarNode x;if(s->top<0){x.num=0;x.arrtime.hour=0;x.arrtime.minute=0;return(x); //假如栈空,返回空值}else{s->top--;return(s->stack[s->top+1]); //栈不空,返回栈顶元素}}/*初始化队列*/void InitLinkQueue(LinkQueueCar *q){q->front=(QueueNode*)malloc(sizeof(QueueNode)); //产生一个新结点,作头结点if(q->front!=NULL){q->rear=q->front;q->front->next=NULL;q->front->num=0; //头结点的num保存队列中数据元素的个数}}/*数据入队列*/void EnLinkQueue(LinkQueueCar *q,int x){QueueNode *p;p=(QueueNode*)malloc(sizeof(QueueNode)); //产生一个新结点p->num=x;p->next=NULL;q->rear->next=p; //新结点入队列q->rear=p;q->front->num++; //队列元素个数加1}/*数据出队列*/int DeLinkQueue(LinkQueueCar *q){QueueNode *p;int n;if(q->front==q->rear) //队空返回0return(0);else{p=q->front->next;q->front->next=p->next;if(p->next==NULL)q->rear=q->front;n=p->num;free(p);q->front->num--;return(n); //返回出队的数据信息}}/********************* 车辆到达***************************/ //参数:停车栈停车队列车辆信息//返回值:空//功能:对传入的车辆进行入栈栈满则入队列void Arrive(SqStackCar *stop,LinkQueueCar *lq,CarNode x){int f;f=push(stop,x); //入栈if (f==0) //栈满{EnLinkQueue(lq,x.num); //入队printstop(1,lq->front->num,0,23);printlog(x.arrtime,x.num,1,'B',lq->front->num,0);qingping(0); printf("您的车停在便道%d号车位上\n",lq->front->num); //更新对话}else{printstop(0,stop->top+1,0,23);printlog(x.arrtime,x.num,1,'P',stop->top+1,0);qingping(0); printf("您的车停在停车场%d号车位上\n",stop->top+1); //更新对话}qingping(1); printf("按任意键继续");getch();}/************************** 车辆离开*************************************///参数:停车栈指针s1,暂存栈指针s2,停车队列指针p,车辆信息x//返回值:空//功能:查找栈中s1的x并出栈,栈中没有则查找队p中并出队,打印离开收费信息void Leave(SqStackCar *s1,SqStackCar *s2,LinkQueueCar *p,CarNode x){double fee=0;int position=s1->top+1; //车辆所在车位int n,f=0;CarNode y;QueueNode *q;while((s1->top > -1)&&(f!=1)) //当栈不空且未找到x{y=pop(s1);if(y.num!=x.num){n=push(s2,y);position--;}elsef=1;}if(y.num==x.num) //找到x{gotoxy(33,17);printf("%d:%-2d",(x.arrtime.hour-y.arrtime.hour),(x.arrtime.minute-y.arrtime.minute) );fee=((x.arrtime.hour-y.arrtime.hour)*60+(x.arrtime.minute-y.arrtime.minute))*PRICE+BASEP RICE;gotoxy(48,17); printf("%2.1f元\n",fee);qingping(0); printf("确认您的车辆信息");qingping(1); printf("按任意键继续");getch();while(s2->top>-1){ y=pop(s2);f=push(s1,y);}n=DeLinkQueue(p);if(n!=0){y.num=n;y.arrtime=x.arrtime;f=push(s1,y);printleave(p->front->num+1,position,s1->top+1); //出栈动画ji队列成员入栈printlog(x.arrtime,x.num,0,'P',position,fee);printlog(y.arrtime,y.num,1,'P',s1->top+1,0);}else{printleave(0,position,s1->top+2);printlog(x.arrtime,x.num,0,'P',position,fee);}}else //若栈中无x{while(s2->top > -1) //还原栈{y=pop(s2);f=push(s1,y);}q=p->front;f=0;position=1;while(f==0&&q->next!=NULL) //当队不空且未找到xif(q->next->num!=x.num){q=q->next;position++;}else //找到x{q->next=q->next->next;p->front->num--;if(q->next==NULL)p->rear=p->front;gotoxy(33,17); printf("0:0");gotoxy(48,17); printf("0元");qingping(0); printf("您的车将离便道");qingping(1); printf("按任意键继续");getch();printleave(-1,position,p->front->num+1); //出队动画printlog(x.arrtime,x.num,0,'B',position,0);f=1;}if(f==0) //未找到x{qingping(0); printf("停车场和便道上均无您的车");qingping(1); printf("按任意键继续");getch();}}}/*获取系统时间*///返回PTime类型PTime get_time(){Time *t;t=new Time;time_t timer;struct tm *tblock;timer=time(NULL);tblock=localtime(&timer);t->minute=tblock->tm_min;t->hour=tblock->tm_hour;return t;}/*移动光标*///蒋光标移动到(x,y)点void gotoxy(int x,int y){COORD coord;coord.X=x;coord.Y=y+3;SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),coord); }/*画图*///画出系统界面void panitPL(){gotoxy(20,4);printf("****************对话框****************");int x=18,y=6; //起始点int a[2][4]={2,0,0,1,-2,0,0,-1}; //方向for(int i=0;i<2 ;i++){for(int j=0; j<20; j++){x+=a[i][0]; y+=a[i][1];gotoxy(x,y);printf("═");}x+=a[i][0]; y+=a[i][1];gotoxy(x,y);if(i==0)printf("╗");elseprintf("╚");for(j=0; j<12; j++){x+=a[i][2]; y+=a[i][3];gotoxy(x,y);printf("║");}x+=a[i][2]; y+=a[i][3];gotoxy(x,y);if(i==0)printf("╝");elseprintf("╔");}gotoxy(22,8);printf("小王:");gotoxy(22,11);printf("顾客:");gotoxy(22,14); printf("*********** 停车信息***********");gotoxy(23,15); printf("车牌号:");gotoxy(42,15); printf("时间:");gotoxy(23,17); printf("停车时长:");gotoxy(42,17); printf("收费:");}/*清屏函数*///更新对话框前将原对话晴空void qingping(int a){if(a==0) //清空小王的对话{gotoxy(28,8); printf(" ");gotoxy(28,9); printf(" ");gotoxy(28,8);}else if(a==1) //清空顾客的对话{gotoxy(28,11); printf(" ");gotoxy(28,12); printf(" ");gotoxy(28,13); printf(" ");gotoxy(28,11);}else //清空车辆信息{gotoxy(31,15); printf(" ");gotoxy(48,15); printf(" ");gotoxy(33,17); printf(" ");gotoxy(48,17); printf(" ");gotoxy(31,15);}}//用上下键移动选择int getkey(){char c;int x=28,y=11;while(1){gotoxy(x,11); printf(" ");gotoxy(x,12); printf(" ");gotoxy(x,13); printf(" ");gotoxy(x,y); printf(">>");c=getch();if(c==13) return y-10; //enter键返回当前选项if(c!=-32)continue; //不是方向键进行下次循环c=getch();if(c==72) if(y>11) y--; //上if(c==80) if(y<13) y++; //下}}//输入车辆信息CarNode getcarInfo(){PTime T;CarNode x;qingping(0); printf("请输入您的车牌号\n");qingping(1); printf("在下面输入车辆信息");qingping(2);scanf("%d",&(x.num));T=get_time();x.arrtime=*T;gotoxy(48,15); printf("%d:%d",x.arrtime.hour,x.arrtime.minute);getch();return x;}//打印停车场void printcar(){gotoxy(0,20); //╔ ╗╝╚═║printf("═══════════════════════════════════════╗");printf(" 出场暂放区║ 1 2 3 4 5 ║");printf("---------------------------------------------------------------------- ║");printf(" 主车道║");printf("---------------------------------------------------------------------- ║");printf(" 12 11 10 9 8 7 6 5 4 3 2 1 ║");printf("═══════════════════════════════════╗ ║");printf(" ↑ ╔══════════════╝ ║");printf(" 便道停车区→ ║ 1 2 3 4 5 ║");printf(" ╚══════════════════╝");printf(" 停车场管理日记\n\n");printf(" 时间车牌号进(1)/出(0) 车位(B便道P停车场) 收费(元) "); }//打印日记记录void printlog(Time t,int n,int io,char ab,int po,double f){jy++;gotoxy(jx,jy);// printf(" 时间车牌号进(1)/出(0) 车位(B便道P停车场) 收费(元) ");if(io==0)printf("/ %2.1f",f);gotoxy(jx,jy);printf(" / %d / %c:%d",io,ab,po);gotoxy(jx,jy);printf(" %d:%d / %d",t.hour,t.minute,n);}void printstop(int a,int num,int x0,int y0){static char *car="【█】";// int x0=0,y0=23;int x=0,y=28;if(a==0){x=(num+6)*6;for(;x0<72;x0++){gotoxy(x0,y0); printf("%s",car); Sleep(30);gotoxy(x0,y0); printf(" ");}for(;y0<y;y0++){gotoxy(x0,y0); printf("%s",car); Sleep(100);gotoxy(x0,y0); printf(" ");}for(;x0>x;x0--){gotoxy(x0,y0); printf("%s",car); Sleep(50);gotoxy(x0,y0); printf(" ");}gotoxy(x,y);printf("%s",car);}else{x=(12-num)*6;y=y-3;for(;x0<x;x0++){gotoxy(x0,y0); printf("%s",car); Sleep(30);gotoxy(x0,y0); printf(" ");}gotoxy(x,y);printf("%s",car);}}void printleave(int a,int po,int num){static char *car="【█】";int x0=0,y0=23;int x=0,y=28;int i;if(a==-1){x=(12-po)*6;y=y-3;gotoxy(x,y); printf(" ");gotoxy(x,y-2); printf("%s",car);Sleep(100);if(12>num){gotoxy((12-num)*6,y);printf(" ");}gotoxy(x,y); printf("%s",car);for(;x>x0;x--){gotoxy(x,y-2); printf("%s",car); Sleep(30);gotoxy(x,y-2); printf(" ");}}else{i=num+1;for(;num>po;num--){x=(num+6)*6; y=28;for(;x<72;x++){gotoxy(x,y); printf("%s",car); Sleep(30);gotoxy(x,y); printf(" ");}for(;y>21;y--){gotoxy(x,y); printf("%s",car); Sleep(50);gotoxy(x,y); printf(" ");}for(;x>(i-num+6)*6;x--){gotoxy(x,y); printf("%s",car); Sleep(30);gotoxy(x,y); printf(" ");}gotoxy(x,y); printf("%s",car);}x=(po+6)*6; y=28;for(;x<72;x++){gotoxy(x,y); printf("%s",car); Sleep(30);gotoxy(x,y); printf(" ");}for(;y>23;y--){gotoxy(x,y); printf("%s",car); Sleep(50);gotoxy(x,y); printf(" ");}for(;x>0;x--){gotoxy(x,y); printf("%s",car); Sleep(30);gotoxy(x,y); printf(" ");}num++;for(;i-num>0;num++){x=(i-num+6)*6; y=21;for(;x<72;x++){gotoxy(x,y); printf("%s",car); Sleep(30);gotoxy(x,y); printf(" ");}for(;y<28;y++){gotoxy(x,y); printf("%s",car); Sleep(50);gotoxy(x,y); printf(" ");}for(;x>(num-1+6)*6;x--){gotoxy(x,y); printf("%s",car); Sleep(30);gotoxy(x,y); printf(" ");}gotoxy(x,y); printf("%s",car);}if(a>0){x=66;y=25;gotoxy(x,y); printf(" ");gotoxy(x,y-2); printf("%s",car); Sleep(100);if(12>a){gotoxy((12-a)*6,y);printf(" ");}if(a>1){gotoxy(x,y); printf("%s",car);}printstop(0,i-1,x,y-2);}}}/************************************************************ main ********************************************************/int main(void){SqStackCar s1,s2; //停车栈和暂存栈LinkQueueCar p; //队列InitSeqStack(&s1);InitSeqStack(&s2);InitLinkQueue(&p);printf(" 停车场管理系统\n\n");printf("************************* 欢(=^_^=)迎***************************\n");printf(" 收费标准:基础费0.5元,每分钟收取0.05元,收费精确到0.1元\n");printf(" PS:车牌号由阿拉伯数字组成");panitPL();printcar(); gotoxy(0,-3);char c=0; //接受按键while(1) //按ESC退出系统{for(int i=2;i>-1 ;i--) //初始化对话框qingping(i);printf("按ESC退出系统,其它键开始对话");c=getch();if(c==Esc){qingping(0);break;}while(1){qingping(2);gotoxy(28,8); printf("欢迎来到停车场!我是管理员小王。

数据结构课程设计停车场管理系统

数据结构课程设计停车场管理系统

试验二停车场管理班级: A0712学号: 12 姓名: 冷清淼成绩: __________指导教师签名: __________一、问题描述设停车场是一种可停放n辆车旳狭长通道, 且只有一种大门可供汽车进出。

在停车场内, 汽车按抵达旳先后次序, 由北向南依次排列(假设大门在最南端)。

若停车场内已停满n辆车, 则后来旳汽车需在门外旳便道上等待, 当有车开走时, 便道上旳第一辆车即可开入。

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

每辆车离开停车场时, 应按其停留时间旳长短交费(在便道上停留旳时间不收费)。

设计规定:1. 模拟上述管理过程。

规定以次序栈模拟停车场, 以链队列模拟便道。

2.从终端读入汽车抵达或拜别旳数据, 每组数据包括三项:(1)是“抵达”还是“离开”;(2)汽车牌照号码;(3)“抵达”或“离开”旳时刻。

3. 与每组输入信息对应旳输出信息为: 假如是抵达旳车辆, 则输出其在停车场中或便道上旳位置;假如是拜别旳车辆, 则输出其在停车场中停留旳时间和应交旳费用。

二、算法阐明1. 数据构造阐明(1)用到两个堆栈: 一种为车场栈;另一种为临时栈temptypedef struct NODE{CarNode *stack[MAX+1];int top;}SeqStackCar; /*模拟车场*/一种队列构造, 存储便道车辆信息:typedef struct Node{QueueNode *head;QueueNode *rear;}LinkQueueCar; /*模拟便道*/2. 算法阐明(1) 功能模块阐明:停车场管理系统具有三个模块, 即:车辆抵达、离开、列表显示图1(2)以模块为单位分析算法1.“抵达”模块: 抵达时有两种状况, 即车场与否满, 未满则直接进入停车场;满时, 到便道等待。

如图2。

图22.“离开”模块:离开时, 当车库为空时, 提醒没有车, 结束;否则车辆离开。

数据结构,停车场管理系统

数据结构,停车场管理系统

数据结构,停车场管理系统
停车场管理系统本人是刚入门的小菜鸡,这个学期刚好学数据结构,想着把写过的问题记录一下,一开始不会写,参考了别人写的,然后才有了点思路,但还是感觉写的有点冗长欢迎各位大佬指出问题,我会努力改进的问题描述:设停车场是一个可停放n 辆汽车的狭长通道,且只有一个大门可供汽车进出。

汽车在停车场内按车辆达到时间的先后顺序,依次由北向南排列(大门在最南端,最先达到的第一辆车停放在车场的最北端),若车场内已停满n辆汽车,则后来的汽车只能在门外的便道上等候,一旦有车开走,则排在便道上的第一辆车即可开入;当停车场内某辆车要离开时,在它之后进入的车辆必须先退车车场为它让路,待赶辆车开出大门外,其它车辆在按原次序进入车场,每辆停放在车场的车在它离开停车场时必须按它停留的时间长短叫纳费用。

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

基本要求(1)以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入的输入数据序列进行模拟管理。

每一组输入数据包括三个数据项:汽车“达到”或“离去”信息、汽车牌照号码以及达到或离去的时刻。

对每一组输入数据进行操作后的输出信息为:若是车辆达到、则输出汽车在停车场内或便道上停车位置;若是车辆离去,则输出汽车在停车场内停留的时间和应交纳的费用(在便道上停留的时间不收费)。

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

(2)最好有操作菜单。

3实现提示:需另设一个栈,临时停放为给要离去的汽车让路而从停车场退出来的汽车,也用顺序存储结构实现。

输入数据按到达或离去的时刻有序。

栈中每个元素表示一辆汽车,包括两个数据项:汽车的牌照号码和进入停车场的时刻。

运行展示。

数据结构停车场模拟管理程序的设计与实现

数据结构停车场模拟管理程序的设计与实现

停车场模拟管理程序的设计与实现一、简介设计停车场模拟管理程序,要求实现4个大的功能模块1.程序功能介绍和操作提示2.汽车进入停车位的管理模块3.汽车离开停车位的管理模块查看停车厂停车状态的的查询模块二、数据结构的设计:(1)停车场停放收费是按照时间来计算,首先要定义一个时间的结构体,并定义出一个最短时间。

typedef struct time{int hour;int min;}Time;(2)为了便于区分每辆汽车并了解每辆车当前所处的位置,需要记录汽车的牌照号码,停放地址和到达时间。

typedef struct car{int num;int position;Time t;double money;}Car;(3)创建栈来构建停车场。

typedef struct{Car elem[N+1];int top;}Stack;(4)创建队列来构建便道,方便汽车出入。

typedef struct Node{Car data;struct Node *next;}QueueNode;(5)当停车场的停车位上都已停满了汽车,又有新的汽车到来时要把它调度到便道上,便道上的车辆要按照进入便道的先后顺序顺次序放在便道上。

当有车从停车位上离开后,便道上的第一辆汽车就立即进入停车位上的某个车位。

typedef struct{QueueNode *front;QueueNode *rear;}LinkQueue;三、功能(函数)设计:本程序从总体上分为四个功能模块,分别为:(1)程序功能介绍,和操作提示模块(2)汽车进入停车位的管理模块(3)汽车离开停车位的管理模块(4)查看停车场状态的查询模块函数功能:(1)进入停车位函数:输入1后进入“进入停车场”函数,然后输入车牌号、到达时间。

然后程序自动提示停放位置,若车位已满,程序将提示“车库已满,请稍等!”。

(2)进入离开停车场函数:输入2后进入“离开停车场”函数,然后车牌号、离开时间。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

停车场管理程序
问题描述:设停车场内只有一个可停放n辆汽车的狭长通道,且只有一个大门可供汽车进出。

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

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

基本要求:每一组输入数据包括三个数据项:汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时刻,对每一组输入数据进行操作后的输出数据为:若是车辆到达,则输出汽车在停车场内或便道上的停车位置;若是车离去;则输出汽车在停车场内停留的时间和应交纳的费用(在便道上停留的时间不收费,单位时间的停车费用由用户从键盘输入)。

具体思路是:
1、先编写车到达的情况
2、再写车离去的情况
3、从离去方面在进一步写缴费情况
4、写主函数
这次用到的是链的算法和全局变量的和switch的算法(看程序)
数据测试结果
程序总结和心得:
这个题目内容死板,不容易写,死了许多脑细胞;
但也再次扩展了我知识,把单链表再次熟练
总的来说很累!!!
#define n 3//定量小,好观察
#define price 0.05 // 定义价格为每分钟0.05 元
#include "stdio.h"
#include "stdlib.h"
typedef struct TIME//时间的结构
{
int hour;
int min;
}time;
typedef struct record
{
int num;//汽车牌照号码
time reach;//到达时刻
time leave;//离开时刻
}datatype;
typedef struct node
{
datatype data;//结点数据域
struct node *next;//结点的指针域
}link;
link *head;//头指针
link *park(head,i)//车达到的函数,i是全局变量,不声明
link *head;
{
link *p;
if(i<=n)
{
p=(struct node*)malloc(sizeof(link));//给一个存放结点的内存空间
printf("\n 请输入车牌号(例:鄂B1234):");
scanf("%d",&(p->data.num));
printf("\n 车辆到达时间:");
scanf("%d:%d",&(p->data.reach.hour),&(p->data.reach.min));//":"是为了控制时间的输入格式
p->next=head->next;//把头指针的地址域给p
head->next=p;//头指针再指向p
}
else
{
printf("\n\t\t停车场已满,请在便道稍等!\t\t\n");
return (head);//返回头指针
}
return(head);//最后返回头指针
}
void PRINT(link *p,int x)// 车辆收费
{
int A1,A2,B1,B2;
printf("\n 车辆离开的时间:");
scanf("%d:%d",&(p->next->data.leave.hour),&(p->next->data.leave.m in));//这是根据查找而写的,表示返回的p是前驱结点
printf("\n 其到达时间为: %d:%d",p->next->data.reach.hour,p->next->data.reach.min);
printf("\n 离开时间为: %d:%d",p->next->data.leave.hour,p->next->data.leave.min);
A1=p->next->data.reach.hour;
A2=p->next->data.reach.min;
B1=p->next->data.leave.hour;
B2=p->next->data.leave.min;
printf("\n 应交费用为: %-8.3f 元\n",((B1-A1)*60+(B2-A2))*price);//钱的算法
}
link *key_search(head,key)//查找key被删除功能调用,找前驱结点
link *head;int key;
{
link *p;
p=head;
while(p->next!=NULL)
{
if(p->next->data.num!=key)
p=p->next;
else
return(p);
}
return(NULL);//查找失败,返回空指针NULL
}
link *key_delete(head)
link *head;
{
link *p;int x;
printf("离开的车请输入车牌号:");
scanf("%d",&x);
p=key_search(head,x);//前驱结点
if(p!=NULL)
{
PRINT(p,x);
p->next=p->next->next;//把结点删除
return(head);
}
else
{
printf("\n\t\t输入的%d车牌不在,请重新输入数据!\n",x);
return(head);
}
}
void list(head)//列表
link *head;
{
link *p;
p=head;
while(p->next!=NULL)//就如头指向第一个结点
{
printf("车号%d,进去时间%d:%d\n",p->next->data.num,p->next->data.reach.hour,p->next->data.r each.min);
p=p->next;
}
}
main()
{
link *head;
int ch;
int i=1;
head=(struct node*)malloc(sizeof(link));
head->next=NULL;
while(1)//用于循环
{
printf("\n\t *************** 欢迎使用停车场系统.***************\n\n");
printf("\n\t 1. 车辆到达登记.\t\n");
printf("\n\t 2. 车辆离开登记.\t\n");
printf("\n\t 3. 车辆列表显示.\t\n");
printf("\n\t 4. 退出系统.\t\n\n");
printf(" 请选择: ");
while(1)//选项输入限制
{
scanf("%d",&ch);
if(ch>=1&&ch<=4)break;
else printf("\n 输入有误,请重新选择: 1~4: ");
}
switch(ch)
{
case 1:head=park(head,i);i++;list(head);break;//i用于循环
case 2:head=key_delete(head);i--;list(head);break;//i用于控制车数,减少
case 3:list(head);break;
case 4:exit(0);
default: break;
}
}
}。

相关文档
最新文档