基于栈和队列的停车场管理系统设计与实现课程设计

合集下载

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

海南大学数据结构课程设计课题名称：停车场管理系统专业:班级:学号:姓名：指导老师:年月日目录一课程设计目的 ............................................................ 错误!未指定书签。

二问题描述................................................................... 错误!未指定书签。

三需求分析. (1)四概要分析 (2)1 设计思想 (2)2 实现方法 (2)3 程序模块 (2)五详细设计 (3)六源程序代码................................................................. 错误!未指定书签。

七程序调试 (13)八课程设计感想 (16)九参考文献 (17)一、课程设计目的1、通过课程设计，加深对《数据结构》这一课程所学内容的进一步理解与巩固。

2、通过课程设计，加深对结构化设计思想的理解，能对系统功能进行分析，并设计合理的模块化结构。

3、通过课程设计，训练C程序调试能力，能将一个中小型各级组织系统联调通过。

4、通过课程设计，开发一个中小型系统，掌握系统研发全过程。

5、通话课程设计，培养分析问题、解决实际问题的能力。

二、问题描述：假设有一个可以停放n辆汽车的狭长停车场，它只有一个大门可以供车辆进出。

问题要求汽车停车场内按车辆到达时间的先后顺序，依次由北向南排列。

由此很容易联想到数据结构中的堆栈模型，因此可首先设计一个堆栈，以堆栈来模拟停车场，又每个汽车的车牌号都不一样，这样一来可以根据车牌号准确找到汽车位置，所以堆栈里的数据元素我设计成汽车的车牌号。

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

这是个一退一进的过程，而且让道的汽车必须保持原有的先后顺序，因此可再设计一个堆栈，以之来暂时存放为出站汽车暂时让道的汽车车牌号。

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

《数据结构与算法》课程设计任务书题目：停车场管理系统学生姓名：李雷正学号：16480217 班级：物联网工程二班题目类型：停车场管理系统指导教师：一．题目简介该设计要求学生以停车场管理业务为背景，设计出一个简单的能够实现停车场管理功能的系统。

通过该题目的设计过程，可以加深理解线性表的逻辑结构、存储结构，掌握栈、队列上基本运算的实现，进一步理解和熟练掌握课本中所学的各种数据结构，学会如何把学到的知识用于解决实际问题，培养学生的动手能力。

二．主要任务第一部分：基本算法实现1、线性结构基本算法实现（指导老师根据题目指定）；2、树型结构基本算法实现（指导老师根据题目指定）；3、图型结构基本算法实现（指导老师根据题目指定）；4、查找基本算法实现（指导老师根据题目指定）；5、排序基本算法实现（指导老师根据题目指定）；第二部分：指定题目的设计与实现1、查阅文献资料，一般在3篇以上；2、建立数据的逻辑结构和物理结构；3、完成相应算法的设计；4、完成测试工作；5、撰写设计说明书；6、做好答辩工作。

三．主要内容、功能及技术指标（1）使用链表或顺序表实现数据的录入（顺序表或链表的创建）、查找、修改、插入、追加、删除、排序、统计、输出等功能；（2）建立一个测试的数据表，至少要有20个测试数据，算法对于这些合法的输入数据都能产生满足规格说明要求的结果；（3）算法对于精心选择的典型、苛刻而带有刁难性的几组输入数据能够得出满足规格说明要求的结果；对算法实现过程中的异常情况能给出有效信息；（4）车辆基本情况包括的数据项有：汽车到达或离开的信息、汽车牌照号码、到达或离去的时刻等；（5）要求：若车辆到达，则输出汽车在停车场内或便道上的停车位置；若车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用。

四．提交的成果1. 设计说明书一份，内容包括：1) 中文摘要100字；关键词3-5个；2) 序言；3）采用类c语言定义相关的数据类型4）各模块的伪码算法5）函数的调用关系图6）调试分析a、调试中遇到的问题及对问题的解决方法；b、算法的时间复杂度和空间复杂度。

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

数据结构实验报告实验二栈和队列实验班级：计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.主程序模块处理过程描述首先输入该车辆信息，判断是否是输入结束标志，是则跳出循环，否则判断是否是进入的车辆，如果是进入的车辆，那么判断此时栈是否已经满了，如果此时栈已满，那么该车辆就要入队列，否则入栈。

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

名目名目
TOC \o 1-3 \h \z \u 二、名目 1 三、设计任务书 2 四、小组成员及分工 3 五、报告正文 3 1.设计题目 3 2.设计目的 3 3.算法思想分析 3 4.算法描述与实现 3 5.程序运行结果 10 6.结论 11 设计任务书
学与技术课程设计教材及主要参考资料：《数据结构课程设计》，滕国文编著，清华大学出版社，20XX 年；《数据结构课程设计》，陈越钦铭雁编著，XX 大学出版社，20XX 年《数据结构课程设计案例教程》, 马巧梅等编著, RM 邮电出版社，20XX 年
//假如返回值为 -1 ，证明停车场已满，需要停在便道中
第1页共1页
本文格式为 Word 版，下载可任意编辑，页眉双击删除即可。
if (result==-1) {//停在便道上
time=leveTime-cr.rr;
ccessrod[til]=cr;
printf(该车停留的时间为：%d 小时,应缴费用为：%f 元
printf(出停车场的车的车牌号以及离开的时间：\n);
为：\n,cr.num);
scnf(%d %d,crNumber,leveTime);
汽车让路而从停车场退出来的汽车。
报告正文
算法描述与实现
第1页共1页
本文格式为 Word 版，下载可任意编辑，页眉双击删除即可。
程序中设置好停车场〔栈〕的最大容量〔3 个〕和每小时的停车费用 \n);
〔1.5 元/小时〕。程序执行，先确定车辆的到达与离去〔到达 D 离去〕
while (scnf(%c,order)) {
}znInode;
cr.num=crNumber;
模拟便道队列
cr.rr=rriveTime;

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

课程设计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. 性能测试结果在高并发情况下，系统运行稳定，性能良好。

栈与队列的应用：停车场管理

栈与队列的应⽤：停车场管理设停车场是⼀个可停放n辆车的狭长通道，且只有⼀个⼤门可供汽车进出。

在停车场内，汽车按到达的先后次序，由北向南依次排列（假设⼤门在最南端）。

若车场内已停满n辆车，则后来的汽车需在门外的便道上等候，当有车开⾛时，便道上的第⼀辆车即可开⼊。

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

每辆车离开停车场时，应按其停留时间的长短交费（在便道上停留的时间不收费）。

试编写程序，模拟上述管理过程。

要求以顺序栈模拟停车场，以链队列模拟便道。

从终端读⼊汽车到达或离去的数据，每组数据包括三项：①是“到达”还是“离去”；②汽车牌照号码；③“到达”或“离去”的时刻（获取系统时间，以秒为单位）。

与每组输⼊信息相应的输出信息为：如果是到达的车辆，则输出其在停车场中或便道上的位置；如果是离去的车辆，则输出其在停车场中停留的时间和应交的费⽤。

（提⽰：需另设⼀个栈，临时停放为让路⽽从车场退出的车。

）第⼀次发出的代码没有考虑在为要出车库的车挪地⽅的时候会把真实时间覆盖，现在⼜在代码中加⼊了挪动操作，时间不进⾏改变。

代码如下：#include<stdio.h>#include<time.h>#include<stdlib.h>#include<string.h>#include<math.h>#define PARK_SIZE 5//定义车的结构体typedef struct{int plateNum;time_t ariTine;//进库时间time_t leaTime;// 出库时间}Car;//车库，⽤顺序栈表⽰typedef struct{Car park[PARK_SIZE];int top;}seqParkList;//便道，⽤链队列表⽰typedef struct LoadNode{Car loadnode;LoadNode *next;}LoadNode, *LoadList;//Park1为车库，Park2为中间车库来安放为Park1重要出栈的腾位置的车seqParkList Park1, Park2;//Load为便道LoadList Load;//初始化车库（栈）void InitSeqStack(seqParkList *top){top->top = -1;}//初始化便道（队列）void InitQueue(LoadList *Q){*Q = (LoadList)malloc(sizeof(LoadNode));(*Q)->next = NULL;}//车出⼩道（出队列）int DeletQueue(Car *car){LoadNode *tcar;tcar = Load->next;if(tcar == NULL) return0;*car = tcar->loadnode;Load->next = tcar->next;free(tcar);return1;}//车进⼊⼩道，并且返回在⼩道的位置int EnterQueue(Car *car){//尾插创建队列int order = 0;LoadNode *p1, *p2;p1 = p2 = Load;LoadNode *newCar = (LoadNode *)malloc(sizeof(LoadNode));//找到队尾，顺便返回即将被放在便上车的位置while(p1 != NULL){order++;p2 = p1;p1 = p1->next;}newCar->loadnode = *car;p2->next = newCar;newCar->next = NULL;return order;}//判断车库是否停满bool isFull(){if(Park1.top == PARK_SIZE - 1) return true;return false;}//车进车库（进栈）int Push(seqParkList *S, Car *car){if(S->top == PARK_SIZE - 1) return -1;S->top++;//进库时获取当前系统的时间time(&car->ariTine);S->park[S->top] = *car;return S->top;}//此时仅做进车库操作，不算更新车进出库时间，因为只是为要出库得车腾地⽅⽽进⾏的动作int MoveIn(seqParkList *S, Car *car){if(S->top == PARK_SIZE - 1) return -1;S->top++;S->park[S->top] = *car;return S->top;}//车出库（出栈）int Pop(seqParkList *S, Car *car){if(S->top == -1) return S->top;*car = S->park[S->top];//出车库时获取当前系统的时间time(&car->leaTime);S->top--;return S->top + 1;}//此时仅做出车库操作，不算更新车进出库时间，因为只是为要出库得车腾地⽅⽽进⾏的动作int MoveOut(seqParkList *S, Car *car){if(S->top == -1) return S->top;*car = S->park[S->top];S->top--;return S->top + 1;}//获取车库最外的车（获取栈顶元素）int GetTop(seqParkList *S, Car *car){if(S->top == -1) return S->top;*car = S->park[S->top];return S->top;}//返回车库（栈）是否为空bool isParkEmpty(seqParkList *park){if(park->top == -1) return true;return false;}//⽐较两个车的信息bool ComCar(Car c1, Car c2){if(c1.plateNum == c2.plateNum) return true;return false;}//车到达进⾏相应的操作void CarIn(Car *car){int order;//只要车到来就进⼊便道，接下来在看要不要进车库order = EnterQueue(car);if(isFull()){//如果车库满了则输出⼀下信息printf("车在便道 %d位置\n", order);}else{//反之车库没满Car tcar;DeletQueue(&tcar);//出便道，order = Push(&Park1, &tcar);//进车库printf("车在车库 %d位置\n", order + 1);}}//车离开进⾏相应的操作void CarOut(Car *car){if(isParkEmpty(&Park1)){//如果车库为空便输出相应的信息printf("Garage is empty!\n");}else{Car c1;GetTop(&Park1, &c1);//如果车库最外边不是将要出库的车，便从栈中挪出//存⼊另⼀个栈，直到车库最外边为要出库的车while(!ComCar(c1, *car)){MoveOut(&Park1, &c1);MoveIn(&Park2, &c1);GetTop(&Park1, &c1);}int order = Pop(&Park1, &c1);//输出出库车在停车场停留时间，并且计算费⽤，假设10秒2元，11-20s都算4元printf("此车在车库停留 %lds 并且花费 %d 元（10s/2元）!\n", c1.leaTime - c1.ariTine, (c1.leaTime - c1.ariTine + 9 ) / 10 * 2);//然后把Park2中的车重新放回Park1while(!isParkEmpty(&Park2)){MoveOut(&Park2, &c1);MoveIn(&Park1, &c1);}}//车库出了⼀个车，便道上的车便要进⼊车库 Car c1;if(DeletQueue(&c1)){Push(&Park1, &c1);}}int main(){InitQueue(&Load);InitSeqStack(&Park1);InitSeqStack(&Park2);seqParkList park1, park2;LoadList Load;Car car1;printf("请输⼊车牌号，动作\n");char action[6];scanf("%d %s", &car1.plateNum, action);//直到输⼊车牌号为0结束程序while(car1.plateNum){if(strcmp(action, "到达") == 0){CarIn(&car1);}else if(strcmp(action, "离去") == 0){CarOut(&car1);}printf("请输⼊车牌号，动作\n");scanf("%d %s", &car1.plateNum, action); }}运⾏结果：。

栈和队列及其应用——停车场管理

华北水利水电大学数据结构实验报告2013～2014学年第二学期2013级计算机科学与技术（专升本）专业班级：208 学号：201320836 姓名：高攀实验二栈和队列及其应用一、实验题目：栈和队列及其应用——停车场管理二、实验内容：设停车场是一个可停放n辆车的狭长通道，且只有一个大门可供汽车进出。

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

编写按上述要求进行管理的模拟程序。

可以将停车场定义成一个顺序栈s0，便道定义成一个链队列q，而停车场中的某辆车要离开，则在它后面进停车场的车必须让道，让其离开，所以必须有一个临时的顺序栈s1，存放让道的车辆。

当有车辆进停车场时，若栈s0不满，则直接进入栈s0；若栈s0满，则进入便道（链队列q）。

若有s0中车辆x离开时，先让在x后面进栈的车从s0退栈并进入栈s1中，让x离开并收取停车费（在便道上停留的时间不收费），然后再把s1中所有元素退栈并重新进入s0栈，最后，将链队列q中的队头元素出队并进栈到s0中。

三、程序源代码：#include<stdio.h>#include<stdlib.h>#define OVERFLOW -1#define N 2#define PRICE 20#define STACK_INIT_SIZE 100//构造顺序栈结构typedef struct data{int num; //车牌号int Atime; //车到达时间}data;typedef struct{data *base;data *top;int stacksize;}SqStack;//构造链队列结构typedef struct QNode{int num; //车牌号struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;//队头指针QueuePtr rear;//队尾指针}LinkQueue;void InitStack(SqStack &s){//构造一个空栈ss.base=(data *)malloc(STACK_INIT_SIZE*sizeof(data));if(!s.base) exit (OVERFLOW); //存储分配失败s.top=s.base; //栈空的条件int sistacksize=STACK_INIT_SIZE;}//InitStackbool StackEmpty(SqStack &s){//若栈s为空栈，则返回TRUE，否则返回FLASEif(s.top==s.base) return true;elsereturn false;}int GetTop(SqStack &s){int e;//若栈不空,则用e返回s的栈顶元素，并返回OK;否则返回ERRORif(s.top==s.base) return false;e=(s.top-1)->Atime;return e; //返回车进站的时间}//GetTopvoid Push(SqStack &s,int e,int e1)//e表示车牌号 e1表示车进站时间{//插入元素e为新的栈顶元素s.top->num=e;s.top->Atime=e1;s.top++;}//Pushint Pop(SqStack &s){int e;//删除s的栈顶元素，用e返回其值s.top--;e=s.top->num;return e; //返回车牌号}//Pop//---------------------------------void InitQueue(LinkQueue &q){//构造一个空队列qq.front=q.rear=(QueuePtr)malloc(sizeof(QNode));if(!q.front) exit(OVERFLOW);q.front->next=NULL;}void EnQueue(LinkQueue &q,int e) //e表示车牌号{//插入元素e为q的新的队尾元素QueuePtr p;p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(OVERFLOW);//存储分配失败p->num=e;p->next=NULL;q.rear->next=p;q.rear=p;}int DeQueue(LinkQueue &q){int e;//若队列不空，则删除q的队头元素，用e返回其值，并返回OK;否则返回ERROR if(q.front==q.rear) return false;QueuePtr p;p=q.front->next;e=p->num;q.front->next=p->next;if(q.rear==p) q.rear=q.front;free(p);return e; //返回车牌号}bool QueueEmpty(LinkQueue &q){ //若队列q为空队列，则返回TRUE，否则返回FLASEif(q.front==q.rear) return true;elsereturn false;}void Car(SqStack &s0,SqStack &s1,LinkQueue &q,int n){//构造两个空栈s0 s1 一个空链队列qInitStack(s0);InitStack(s1);InitQueue(q);char solu; //车的状态：到达(A),离开(D),结束(E)int count=0,Atime,Dtime,num,e,e1,m=0;//count 停车场的车辆数 Atime 车进站时刻 Dtime 车离开时间 num 车牌号 e 返回的车牌号 e1返回的车进站时刻while(m==0){printf("请输入车的状态：到达(A),离开(D),结束(E)\n");scanf("%c",&solu);if(solu=='A'){printf("请输入车牌号以及车到达的时刻(1-24)：\n");scanf("%d %d",&num,&Atime);if(count>=n) //停车场满了，车停进门外的便道即链队列{EnQueue(q,num);printf("停车场满了，车牌号为%d的车停进门外的便道!\n",num);}if(count<n) //停车场未满，车进站即进入栈s1{printf("车牌号为%d的车进站！\n",num);Push(s0,num,Atime);count++;}}m=0;if(solu=='D'){printf("请输入车牌号以及车离开的时刻：\n");scanf("%d %d",&num,&Dtime);while(!StackEmpty(s0)){e1=GetTop(s0); //得到栈顶元素到达时间e=Pop(s0);//得到栈顶元素车牌号if(e==num){printf("车牌号为%d的车出站!\n",num);printf("输出该车在停车场停留的时间以及要付的费用：\n");printf("%d %d\n",Dtime-e1,(Dtime-e1)*PRICE);count--;while(!StackEmpty(s1)){e1=GetTop(s1);e=Pop(s1);printf("车牌号为%d的车由临时车站进入车站!\n",e);Push(s0,e,e1);count++;}if(!QueueEmpty(q)){e=DeQueue(q);printf("车牌号为%d的车进站！\n",e);printf("输入车牌号为%d的车的由便道进入车站的时间!\n",e);scanf("%d",&Atime);Push(s0,e,Atime);count++;}break;}else{ printf("车牌号为%d的车进入临时车站!\n",e);Push(s1,e,e1);count--;}}m=0;}if(solu=='E'){printf("停车场关门，输出停车场以及便道上车的信息！\n");while(!StackEmpty(s0)){e1=GetTop(s0); //得到栈顶的元素中的到达时间e=Pop(s0);//得到栈顶的元素中的车牌号printf("输出车牌号为%d的车在停车场停留的时间以及要付的费用：\n",e);printf("%d %d\n",24-e1,(24-e1)*PRICE);}while(!QueueEmpty(q)){e=DeQueue(q);printf("输出在便道上的车的车牌号：%d\n",e);}m=1;}}}int main(){void Car(SqStack &s0,SqStack &s1,LinkQueue &q,int n);SqStack s0,s1;LinkQueue q;Car(s0,s1,q,N);return 0;}四、测试结果：五、小结（包括收获、心得体会、存在的问题及解决问题的方法、建议等）车进站这个实验花费了我相当多的时间，虽然老师给了我们做题的思路，但由于我栈的内容没学扎实，因此在计算停车时间的时候遇到了不能解决的问题，后来参考了网上的做法才知道栈里面可以存放节点，这个问题才得以解决。

基于栈和队列的停车场管理系统设计与实现课程设计

长春建筑学院《数据结构》课程设计（论文）基于栈和队列的停车场管理系统设计与实现Stack and queue-based parking management system design andImplementation年级:学号:姓名:专业 :指导老师:二零一三年十二月摘要计算机科学技术的发展，不仅极大地促进了整个科学技术的发展，而且明显地加快了经济信息化和社会信息化的进程。

因此，计算机教育在全国备受重视，计算机知识与能力已成为21世纪人才素质的基本要素之一。

如今，高等教育的计算机教育发展十分迅速。

十多年前，只有部分理工科专业开设计算机课程。

今天，几乎所有高校的所有专业都开设了程度不同的计算机课程。

人们已经认识到，计算机知识已成为当代知识分子知识结构中不可缺少的重要组成部分。

而除了掌握计算机的基础知识和操作的基本能力外，掌握一门高级编程语言，并可以熟练运用它，已成为当代大学生综合能力必要组成。

计算机技术发展如此迅猛，计算机应用如此广泛，需要学习的东西愈来愈多，而我们的总学时是有限的。

一般来说，计算机课程学习可以分为两部分：一部分是理论课程学习，一部分是上机应用实习。

根据我们专业的性质和要求，则应侧重于上机操作运用。

关键字：计算机上机应用实习AbstractDevelopment of computer science and technology, not only greatly promoted the development of the science and technology, but also significantly accelerate the economic and social informatization process of information. Therefore, the country has attracted increasing attention in computer education, computer knowledge and ability has become one of the basic elements of the 21st century, the quality of talent.Today, the computer is very fast development of higher education. Ten years ago, only a part of the creation of computer science and engineering courses. Today, almost all professional colleges and universities have set up all the different levels of computer courses. It has been recognized, computer knowledge has become the contemporary intellectuals important part of the knowledge structure indispensable. And in addition to master the basics of computer operation and basic ability to master a high-level programming language, and can skillfully use it, has become an essential component of contemporary college students' comprehensive ability.Computer technology is growing so fast, computer application so extensive, more and more things to learn, and our total hours are limited. Generally, computer learning courses can be divided into two parts: one is the theoretical courses, practical application part of the machine. According to the nature and requirements of our professional, you should focus on the use of machine operation.Keywords：comptuer Computer application practice目录摘要 (I)ABSTRACT (II)第1章绪论....................................................... - 1 -1.1设计目的 (1)1.2设计内容 (1)1.3设计要求 (2)1.4设计思想 (2)第2章概要设计.................................................... - 3 -2．1抽象数据类型定义.. (3)2．2模块划分 (5)第3章详细设计.................................................... - 7 -3．1数据类型的定义. (7)3．2主要模块的算法描述 (8)第4章系统测试................................................... - 12 -第4章系统测试................................................... - 13 -4.1调试分析 (13)第5章测试结果................................................... - 14 -5.1测试数据及结果 (14)5.2结果分析 (17)第6章课程设计总结............................................... - 18 -第1章绪论引言：课程设计是实践性教学中的一个重要环节，它以某一课程为基础，可以涉及和课程相关的各个方面，是一门独立于课程之外的特殊课程。

停车场管理课程设计

一、绪论数据结构是计算机程序设计的重要理论技术基础，也是计算机学科的核心课程，而课程设计则是考察我们学生对数据结构的熟悉程度及掌握程度。

此次的课程设计是关于停车场管理系统的编程，需要考查的是对栈和队列的熟练使用，以及对基础知识的掌握。

这次的课程设计主要是用栈和队列实现模拟停车场的基本原理，栈的顺序存储结构和队列的链式存储结构的定义和算法描述，同时也学会了编写停车场问题的程序。

二、程序设计2.1、需求分析（1）根据车辆到达停车场到车辆离开停车场时所停留的时间进行计时收费。

进入主菜单前需要输入收费标准以及停车场所能容纳的车辆数目。

（2）当有车辆从停车场离开时，等待的车辆按顺序进入停车场停放。

实现停车场的调度功能。

（3）用顺序栈来表示停车场，链队表示停车场外的便道。

（4）显示停车场信息和便道信息。

（5）程序执行的命令为：○1车辆进入停车场○2车辆离开停车场○3显示停车场的信息。

2.2、概要设计抽象数据类型定义（1）栈的抽象数据类型定义AST Stack{数据对象：D={ai|ai∈ElemSet,i=1,2,...,n, n≥0}数据关系：R1={<ai-1,ai>|ai-1,ai∈D，i=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已存在。

停车管理系统课程设计

停车管理系统课程设计一、课程目标知识目标：1. 让学生理解停车管理系统的作用和重要性，掌握其基本组成部分及功能。

2. 使学生掌握数据结构中与停车管理系统相关的基础知识，如队列、栈等。

3. 帮助学生了解并运用编程语言（如Python或C++）实现简单的停车管理系统。

技能目标：1. 培养学生运用数据结构解决实际问题的能力，能够设计并优化停车管理系统的数据模型。

2. 提高学生的编程能力，使其能够独立完成一个简单的停车管理系统的代码编写和调试。

3. 培养学生团队协作和沟通能力，通过小组合作完成课程项目。

情感态度价值观目标：1. 激发学生对计算机科学和信息技术领域的兴趣，培养其主动学习的态度。

2. 培养学生关注社会问题，认识到信息技术在解决实际生活中的重要作用，增强社会责任感。

3. 引导学生树立正确的价值观，认识到技术应服务于社会，遵循道德规范，保护用户隐私。

本课程针对高年级学生，已具备一定的数据结构知识和编程基础。

课程性质为实践性较强的综合应用课程，旨在通过停车管理系统这一实际案例，使学生将所学知识综合运用到实际项目中。

教学要求注重培养学生的实践能力、创新思维和团队协作能力，通过分解课程目标为具体的学习成果，使学生在完成课程后能够达到预期的知识和技能水平。

二、教学内容1. 停车管理系统概述：- 系统功能介绍- 系统在实际生活中的应用案例2. 数据结构基础：- 队列与栈的应用- 哈希表的原理与实现3. 编程语言选择与使用：- Python/C++语言基础- 编程规范与调试技巧4. 停车管理系统设计与实现：- 系统需求分析- 数据模型设计- 算法设计与优化- 代码编写与测试5. 课程项目：- 小组分工与协作- 项目进度安排与汇报- 项目评价与反馈教学内容根据课程目标，结合课本相关章节，制定以下教学大纲：第1周：停车管理系统概述，数据结构基础第2周：编程语言选择与使用，编程规范与调试技巧第3-4周：停车管理系统设计与实现（需求分析、数据模型设计、算法设计）第5-6周：停车管理系统设计与实现（代码编写与测试）第7周：课程项目启动，小组分工与协作第8周：课程项目中期汇报，项目评价与反馈第9周：课程项目总结，成果展示与分享教学内容科学系统，注重理论与实践相结合，旨在提高学生的实际操作能力和创新思维。

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

数据结构课程设计题目：停车场管理系统姓名：邓全飞学号：201120320105专业：信息和计算科学指导老师：姜俊坡目录一课题分析 (3)二逻辑分析 (3)2.1 数据结构的描述和每个基本操作的功能说明 (3)2.1 给出本程序包含的模块及模块之间的调用关系图 (4)2.3 写出重要部分的伪码算法 (4)三详细设计 (5)3.1 数据结构的定义，及其基本操作的实现 (5)3.2主函数和其他函数的实现或伪码算法 (5)3.3 程序的层次结构的函数调用关系图 (8)3.4 详细设计 (8)四程序源代码 (9)五程序调试和测试 (16)5.1 主界面 (16)5.2 具体操作 (16)5.2.1进站时间和车牌号 (16)5.2.2 车站已满，请进入临时车道 (17)5.2.3 出站和收费 (18)5.2.4 结束 (18)5.3 相关操作 (18)六程序中遇到的问题和解决方法 (19)6.1 写提纲 (19)6.2 在程序调试过程，遇到的相关问题.............. 错误!未定义书签。

七总结.. (20)八参考文献 (21)一课题分析a)该程序主要利用栈和队列来实现车的到达及其离开功能，其中主要有对各种情况的处理，要求如下：1、要求以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的数据序列进行模拟管理2、要求处理的数据元素包括三个数据项：汽车“到达”或“离去”信息，汽车牌照号码及到达或离去的时间3、该系统完成以下功能：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是离去，则输出汽车在停车场内停留的时间和应缴纳的费用（在便道上停留的时间不收费）4、要求栈以顺序结构实现；b)程序的输入，程序功能选择，字符型，A为到达，D离开，E退出系统；车的编号是整型，输入数字即可；时间是float类型，可精确到分钟c)程序的输出，当车到达，程序输出车的编号及到达时间，若栈满则提示停到便道上；车离开时，输出车的编号及其所需费用。

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

停车系统数据结构课程设计一、课程目标知识目标：1. 理解并掌握停车系统中的基本数据结构，如数组、链表、栈和队列。

2. 学会运用数据结构解决停车系统中的实际问题，如车位分配、查找空闲车位等。

3. 掌握分析、设计停车系统数据结构的方法，并能够进行简单优化。

技能目标：1. 培养学生运用所学数据结构进行问题分析、设计解决方案的能力。

2. 提高学生编程实现停车系统数据结构及其相关功能的能力。

3. 培养学生通过合作与交流，共同解决复杂问题的团队协作能力。

情感态度价值观目标：1. 培养学生对数据结构在现实应用中的兴趣，激发学习积极性。

2. 培养学生勇于面对问题，积极寻求解决方案的精神。

3. 增强学生的环保意识，认识到智能停车系统在缓解交通压力、节约资源等方面的价值。

课程性质：本课程为高中年级信息技术课程，结合实际应用场景，培养学生运用数据结构解决实际问题的能力。

学生特点：高中学生具备一定的编程基础，对实际问题有一定的分析能力，但可能在数据结构的应用方面经验不足。

教学要求：注重理论知识与实际应用相结合，引导学生通过自主探究、合作学习，达到学以致用的目的。

同时，关注学生的情感态度发展，培养其正确的价值观。

通过分解课程目标为具体的学习成果，为后续教学设计和评估提供依据。

二、教学内容1. 数据结构基本概念：介绍数据结构的基本概念，如线性结构、非线性结构，以及常见的数据结构种类。

相关教材章节：第一章数据结构概述2. 常见数据结构及应用：- 数组：介绍数组的定义、特点及应用场景，如停车场的车位表示。

- 链表：讲解链表的定义、分类和操作，探讨其在停车系统中的运用，如车辆进出管理。

- 栈和队列：阐述栈和队列的基本概念、操作方法，以及它们在停车系统中的实际应用，如车辆进出顺序控制。

相关教材章节：第二章数组与链表；第三章栈和队列3. 停车系统数据结构设计：- 分析停车系统的需求，设计适合的数据结构模型。

- 介绍如何利用数据结构实现停车场的车位分配、查找空闲车位等功能。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

二程序流程图：三，程序代码：#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'); /*退出操作*/}。

栈和队列及其应用_停车场管理

实验2 栈和队列及其应用--------停车场管理一．需求分析设停车场是一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。

汽车在停车场按到达时间的先后顺序，一次由北朝向南排列（大门在最南边最先到达的第一辆汽车停放在车场最北端），若停车场已满，则以后来的汽车只能停在便道上，一旦有车辆开走，则便道上的第一辆车便可开进车场；当车场某辆车要离开时，在他之后进入的车辆必须先退出车场为其让路，待该车辆开出大门后，其他车辆在按原来顺序开进车场，每辆停放在车场的车辆按其待得时间长短缴纳费用（便道上不收费）。

以栈模拟停车场，以队列模拟便道，按照从终端读入的数据进行模拟管理。

每一组数据包括三个数据项：汽车“到达”或“离开”的信息，汽车牌照号以及到达或离开的时间。

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

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

二．概要设计1.设定栈的抽象数据类型定义：ADT Stack {数据对象：D={ai|ai∈ElemSet,i=1,2,…,n,n>=0}数据关系：R={<ai-1,ai>|ai-1,ai∈D}，约定an为栈顶元素基本操作：InitStack (&S)操作结果:构造一个空栈DestroyStack(&S)初始条件: 栈S已存在操作结果：销毁栈SClearStack(&S)初始条件: 栈S已存在操作结果:将S清为空栈Push(&S,e)初始条件: 栈S已存在操作结果：插入e到栈顶Pop(&S,&e)初始条件: 栈S已存在且非空操作结果：删除栈顶元素用e返回其值Status StackFull(SqStack S)初始条件：栈已存在操作结果：栈满则返回TRUE ，否则返回FALSEStatus StackEmpty(SqStack S)初始条件：栈已存在操作结果：栈空则返回TRUE ，否则返回FALSE} ADT Stackr2.设定队列的抽象数据类型定义：ADT Queue {数据对象：D={ai|ai∈ElemSet,i=1,2,…,n,n>=0}数据关系：R={<ai-1,ai>|ai-1,ai∈D，约定a1为队头，an为对尾部}基本操作：InitQueue (&Q)操作结果:构造一个空队列EnQueue(&Q,e)初始条件: 队列Q已存在操作结果：插入e到队尾DeQueue(&Q,&e)初始条件: 队列Q已存在且非空操作结果：删除队头元素用e返回其值Status QueueEmpty(LinkQueue &Q)初始条件：队列存在操作结果：队列空为真，否则为假} ADT Queue3.本程序包含四个模块：1 Void main(){初始化；while(1){接受用户数据；作出相应操作；}}2 栈模块——实现栈抽象数据类型定义；3 队模块——实现队列抽象数据类型定义4 停车场有关操作三．详细设计#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define True 1#define False 0#define ok 1#define Error 0#define Infeasible -1#define Overflow -2//--*-*-*-*-*-*-*-*-车辆信息定义*-*-*-*-*-*-*//typedef struct{char AD;int car_ID;int time;}car_info;//------------------------------------------------栈----------------------------------////Status表示函数的返回状态typedef int Status;typedef car_info SElemType;#define STACK_INIT_SIZE 100 //存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;Status InitStack(SqStack &S){//构造一个空栈sS.base=(SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));if(!S.base)exit(Overflow); //存储分配失败S.top=S.base;S.stacksize=STACK_INIT_SIZE;return ok;}//InitStackStatus StackFull(SqStack S){//栈满则返回TRUE ，否则返回FALSEif(S.top-S.base>=S.stacksize) return True;else return False;}//栈满吗Status StackEmpty(SqStack S){//栈空则返回TRUE ，否则返回FALSEif(S.top==S.base)return True;else return False;}//栈空吗Status Push(SqStack &S,SElemType e){//插入元素e为新的栈顶元素*S.top=e;S.top++;return ok;}//PushStatus Pop(SqStack &S,SElemType &e){//若栈不空，则删除S的栈顶元素，用e返回其值if(S.top==S.base)return Error;S.top--;e=*S.top;return ok;}//Pop//*-**-*-*-*-*队列*-*-*-*-*-*-*-//typedef car_info QElemType;typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;Status InitQueue(LinkQueue &Q){//构造一个空队列QQ.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.front) exit(Overflow);//存储分配失败Q.front->next=NULL;return ok;}//InitQueueStatus EnQueue(LinkQueue &Q,QElemType e){//插入元素e为Q的新的队尾元素QueuePtr p;p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(Overflow);//存储分配失败p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return ok;}// EnQueueStatus DeQueue(LinkQueue &Q,QElemType &e){//若队列不空，则删除Q的队头元素，用e返回其值，并返回ok;//否则返回Errorif(Q.front==Q.rear)return Error;QueuePtr p;p=Q.front->next;e=p->data;Q.front->next=p->next;if(p==Q.rear)Q.rear=Q.front;free(p);return ok;}//DeQueueStatus QueueEmpty(LinkQueue &Q){if(Q.front==Q.rear)return ok;else return Error;}//*-*-*-*-*-*-*-*-*费用定义函数*-*-*-**-*-*-*-*//int GetFee(car_info now,car_info before){ int NowTime;int BeforeTime;int Fee;NowTime=now.time;BeforeTime=before.time;Fee=(NowTime-BeforeTime)*10;//每分钟10元return Fee;}//-----*-*-*-*-*-*-*-*-*-*-*--*-车辆到达函数-*-*-*-*-*-*-*-*-*-*-//void ArriveF(SqStack &parking,LinkQueue &road,car_info t,int &p,int &a){if(StackFull(parking)){EnQueue(road,t);a++;printf("汽车在便道上第%d个位置\n",a);}//如果停车场栈满，则入队else{ Push(parking,t);p++;printf("在停车场第%d个位置。

停车场管理系统的设计与实现数据结构课程设计

《数据结构》课程设计题目：停车场管理系统班级：网络工程姓名：***学号：E********完成日期：2015年11月15日一．需求分析1.停在便道；2.停在车库;3.从车库移到便道;4.从便道移到车库;5.从车库取车;6.从便道取车;综上所述可知，总共有4种停车方式。

1.若一直停在便道中，需要在进入便道时以浮点数输入进入时间，当选择6取车时，需要输入在便道中停车的时间。

在便道中提车时会显示进入的时间，以及是否需要发票，在计算完停车费用后退出主菜单。

2. 若一直停在车库中，会在进入时检测车库是否满，若不满，允许进入，同样提示输入到达时间，当选择5取车时，需要输入在车库停车时间。

提车时，会显示进入的时间，以及是否需要发票，在计算完停车费用后退到主菜单。

3. 若先在车库停车后又转到便道停车，则会先检测车库是否满了，这是这个情况满足的最大前提，之后需要输入到达车库时间，其实这也没什么用，因为最后计算费用时，只会加上转移位置的20元费用和在便道停的费用。

在提车时会显示有在本停车场转移位置的信息。

4.若先在便道上停车，后又到车库停，原理同3，在此不再赘述。

二．概要设计1.由于栈的特殊出栈入栈顺序，所以所有进入车库的车辆必须遵守“先进后出”的顺序来停车和提车，由于栈是顺序结构，所以在进入车库时需要检测车库是否饱和，在提车时也需要检测车库是否为空；2.同时，队列需要满足“先进先出”的思想，但此次试验用的链式结构，一般来说，不存在饱和情况，但在提车时候需要检测便道是否有车。

3.栈的数据域存放进入车库的时间，车牌，队列节点数据域存放进入便道的时间车牌，设置标记是否在停车场内更改停车位置，有更改则置为1，否则为0。

4.如果一辆车车库移到便道，除了更换进入便道的时间外，车牌号从链表的数据里得到，从便道移到车库也类似。

另外，更改位置前停放费用不计入最后的费用。

5.除了要输入进入时间，在更换停车位置时需要输入进入时间，在最后提车时需要输入离开时间，方便计算总费用。

数据结构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+BASEPRICE;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){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);{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("欢迎来到停车场！我是管理员小王。

课程设计方案停车场管理系统

学号 **********数据结构课程设计设计说明书停车场管理系统起止日期：年月至年月日学生姓名班级成绩指导教师(签字>年月日停车场管理系统一、引言3二、系统总体设计31、设计思路32、系统总体框架图53、系统流程图5三、详细设计71、车辆停车函数及流程图72、车辆离开函数及流程图83、列表显示车场信息函数及流程图94、列表显示便道信息105列表显示菜单函数及流程图11四、总结12参考文献12五、附录13一、引言随着现代化信息技术的发展，人民生活水平快速提高，汽车的数量也飞速增长，于此同时，停车问题越来越受人们的关注，为了使停车场有效管理，停车场管理的信息化成为必然。

我们可以利用所学的知识，编写一个停车场管理系统，以提高管理的效率，提升停车场的竞争力。

本次课程设计，我运用C语言编写停车场管理系统，主要实现汽车停车，离开，收费，停车信息查询，显示等功能，主要实现方式是用栈和队列。

下面对栈和队列进行一下简单介绍。

栈<stack）是一种仅允许在一端进行插入和删除运算的线性表。

栈中允许插入和删除的那一端，称为栈顶<top）。

栈顶的第一个元素称为栈顶元素。

栈中不可以插入和删除的那一端称为栈底。

在一个栈中插入元素，即把新元素放到当前栈顶元素的上面，使其称为新的栈顶元素，即进栈<push）。

从一个栈中删除一个元素，即把栈顶元素删除掉，使其下面的元素成为新的栈顶元素，称为出栈<pop）。

栈遵循后进先出的原则，即后进栈的元素必先出栈。

其中顺序栈是利用一组地址连续的存储单元依次存放从栈底到栈顶的元素。

在C语言中，可以用一维数组描述顺序栈中数据元素的存储区域，并预设一个数组的最大空间。

栈底设置在0下标端，栈顶随着插入和删除元素而变化，可以用一个整形变量top来指示栈顶的位置。

队列是一种限定在表的一端进行插人而另一端进行删除的线性表，与栈相反，队列遵循先进先出的原则。

允许删除的一端，称为队头<front）。