下载文档原格式
利用顺序栈或环形队列编写停车场管理程序。
停车场管理程序可以利用顺序栈或环形队列进行实现，以下是使用顺序栈的示例：```pythonclass ParkingLot:def __init__(self, capacity):self.capacity = capacityself.stack = []def is_full(self):return len(self.stack) == self.capacitydef is_empty(self):return len(self.stack) == 0def park(self, car):if self.is_full():print("停车场已满，无法停车")else:self.stack.append(car)print("车牌号为{}的车辆停车成功".format(car))def unpark(self):if self.is_empty():print("停车场已空，无车辆可以出车")else:car = self.stack.pop()print("车牌号为{}的车辆出车成功".format(car))def display(self):if self.is_empty():print("停车场为空")else:print("停车场状态：")for i in range(len(self.stack)-1, -1, -1):print(self.stack[i])# 示例代码parking_lot = ParkingLot(5)parking_lot.park("车A")parking_lot.park("车B")parking_lot.park("车C")parking_lot.display()parking_lot.unpark()parking_lot.display()parking_lot.park("车D")parking_lot.park("车E")parking_lot.park("车F")```另外，也可以利用环形队列实现停车场管理程序，以下是使用环形队列的示例：```pythonclass ParkingLot:def __init__(self, capacity):self.capacity = capacityself.queue = [None] * capacityself.front = 0self.rear = 0def is_full(self):return (self.rear + 1) % self.capacity == self.frontdef is_empty(self):return self.front == self.reardef park(self, car):if self.is_full():print("停车场已满，无法停车")else:self.queue[self.rear] = carself.rear = (self.rear + 1) % self.capacityprint("车牌号为{}的车辆停车成功".format(car))def unpark(self):if self.is_empty():print("停车场已空，无车辆可以出车")else:car = self.queue[self.front]self.queue[self.front] = Noneself.front = (self.front + 1) % self.capacityprint("车牌号为{}的车辆出车成功".format(car))def display(self):if self.is_empty():print("停车场为空")else:print("停车场状态：")for i in range(self.front, self.rear):print(self.queue[i])# 示例代码parking_lot = ParkingLot(5)parking_lot.park("车A")parking_lot.park("车B")parking_lot.park("车C")parking_lot.display()parking_lot.unpark()parking_lot.display()parking_lot.park("车D")parking_lot.park("车E")parking_lot.park("车F")```以上两种实现方式都可以实现停车场管理程序，具体选择顺序栈还是环形队列取决于实际需求。
实习二栈、队列和递归算法设计-停车场管理一、需求分析1.每一组输入数据包括：汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去的时刻。
2.输出信息：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用。
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’表示输入结束。
4.【选作内容】：两个栈共享空间，思考应开辟数组的空间是多少？5.【选作内容】：停放在便道上的汽车也收费，收费标准比停放在停车场的车。
实习二栈、队列和递归算法设计题目：停车场管理实习时间：2012/10/14一、需求分析1.每一组输入数据包括：汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去的时刻。
2.输出信息：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用。
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’表示输入结束。
4.【选作内容】：两个栈共享空间，思考应开辟数组的空间是多少？5.【选作内容】：停放在便道上的汽车也收费，收费标准比停放在停车场的车。
二、设计二、 1. 设计思想二、（1）存储结构以栈模拟停车场，以队列模拟车场外的便道。
栈以顺序结构实现，队列以链表结构实现。
不需另设一个栈，栈顶空间临时停放为将要离去的汽车让路而从停车场退出来的汽车，栈用顺序存储结构实现。
建筑学院《数据结构》课程设计（论文）基于栈和队列的停车场管理系统设计与实现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 theuse 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模块划分 (6)第3章详细设计.................................................... - 9 -3．1数据类型的定义. (9)3．2主要模块的算法描述 (10)第4章系统测试................................................... - 14 -第4章系统测试................................................... - 15 -4.1调试分析 (15)第5章测试结果................................................... - 16 -5.1测试数据及结果 (16)5.2结果分析 (19)第6章课程设计总结............................................... - 20 -第1章绪论引言：课程设计是实践性教学中的一个重要环节，它以某一课程为基础，可以涉及和课程相关的各个方面，是一门独立于课程之外的特殊课程。
数据结构实验报告实验二栈和队列实验班级：计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;}实验结果截图：。
实验三栈和队列的应用第一篇：实验三栈和队列的应用一、实验目的掌握栈的数据类型描述及栈的特点；掌握栈的顺序存储结构的特点及算法描述；掌握队列的数据类型描述及链式存储结构的特点和算法描述。
二、实验内容停车场管理。
设有一个可以停放n辆汽车的狭长停车场（先进后出），它只有一个大门可以供车辆进出。
车辆按到达停车场时间的先后依次从停车场最里面向大95E8口处停放（最先到达的第一辆车停放在停车场的最里面）。
如果停车场已放满n辆车，则后来的车辆只能在停车场大门外的便道上等待，一旦停车场内有车离开，则排在便道上的第一辆车就可以进入停车场。
停车场内如有某辆车要离开，在它之后进入停车场的车都必须先退出停车场为它让路，待其开出停车场后，这些车再按原来的次序进停车场。
每辆车在离开停车场时，都应根据它在停车场内停留的时间长短交费。
如果停留在便道上的车没进停车场就要离开，允许其离开，不收停车费，并且仍然保持在便道上的车辆次序。
试编程模拟停车场管理。
三、算法描述提示：可以将停车场定义成一个顺序栈s1，便道定义成一个链队列q，而停车场中的某辆车要离开，则在它后面进停车场的车必须让道，让其离开，故还必须有一个临时的顺序栈s2，存放让道的车辆。
当有车辆进停车场时，直接进入s1栈，若s1栈满，则进入便道（链队列q）。
若有s1中车辆x离开时，先让在x后面进栈的车从s1退栈并进栈到s2中，让x离开并收取停车费，然后，再把s2中的所有车辆退栈并重新进入s1栈，最后，将链队列q的队头车辆进栈到s1中并删除队头车辆。
若有链队列q（便道）中的车辆y离开时，从链队列中删除该车辆即可，不收停车费。
车辆的数据可以表示为（车辆编号，到达/离开时间）。
四.程序清单: #include using namespace std;const intStackSize=5;class SeqStack { public:SeqStack(){top=-1;} ~SeqStack(){};void Push(int x);void Push2(int x);int *Return();int Pop(int y);int Count();void PrintStack();private: int data[StackSize];int top;};//入栈void SeqStack::Push(int x){ if(top>=StackSize-1)throw“上溢”;for(int i=0;i<=top+1;i++){if(data[i]==x){cout<<“该车牌已经存在!请重新输入: ”;i=-1;cin>>x;} } top++;data[top]=x;} //返回数组地址int *SeqStack::Return(){ return data;} //临时栈void SeqStack::Push2(int x){ top++;data[top]=x;} //输出函数void SeqStack::PrintStack(){ for(int i=0;i<=top;i++)cout<<“位置为”<int SeqStack::Pop(int y){ if(top==-1)throw“下溢”;int x;x=data[top--];if(y==top+2)data[top+1]=123456789;if(top==-1)data[top+1]=123456789;return x;} //数数int SeqStack::Count(){ return top;}//队列struct Node { int data;Node *next;};class LinkQueue { public: LinkQueue();void EnQueue(int x,int *q);void xzDeQueue(int x);int Count();int DeQueue();private: Node *front,*rear;};//构造函数LinkQueue::LinkQueue(){ Node *s=new Node;s->next=NULL;front=rear=s;} //入队void LinkQueue::EnQueue(int x,int *q){ Node *s=new Node;Node *p=new Node;p=front;while(p){if(p->data ==x){cout<<“便道已有该车牌号,请重新输入: ”;cin>>x;for(int i=0;i<5;i++){if(x==q[i]){cout<<“停车场已有该车牌号,请重新输入: ”;cin>>x;i=-1;}}p=front;} p=p->next;} s->data =x;s->next =NULL;rear->next =s;rear=s;} //出队int LinkQueue::DeQueue(){ if(front==rear)throw“便道无车辆”;Node *p=new Node;int x;p=front->next;x=p->data;front->next =p->next;if(p->next ==NULL)rear=front;delete p;return x;} //计算结点数int LinkQueue::Count(){ Node *p=new Node;p=front;int i=0;while(p&&p->next!=NULL){p=p->next;i++;} return i;} //选择性出队void LinkQueue::xzDeQueue(int x){ if(rear==front)throw“便道无车辆”;Node *p=new Node;p=front;int y;int i=0;for(;p->next!=NULL;p=p->next){if(p->next->data ==x)if(p->next->next!=NULL){Node *q=new Node;q=p->next;y=q->data;p->next =q->next;i=1;delete q;cout<<“车牌号为:”<break;}else{Node *q=new Node;q=p->next;y=q->data;p->next =NULL;i=1;delete q;if(front->next==NULL)rear=front;cout<<“车牌号为:”<break;}} if(i==0)cout<<“无车牌号为:”< SeqStack b;//b是作为临时存放车辆的栈LinkQueue c;//c是作为便道的队列cout<<“tttt1.车辆进入”<cout<<“tttt4.便道车辆离开”<int xh1=1;//xh1为菜单最外层的循环控制变量int time[100];//记录各车辆进入停车场的时间int t1=0;//作为车辆对应的时间编号int money=1;while(xh1==1){cout<<“请选择指令: ”;cin>>zl;switch(zl){case 1:try{int n1=a.Count();int n;cout<<“请输入车牌号: ”;cin>>n;if(n1==4){int *Num=a.Return();for(int i=0;i<=4;i++)if(Num[i]==n){cout<<“停车场已有该车牌号,请重新输入!”; cin>>n;i=-1;}int *CarNum=a.Return();c.EnQueue(n,CarNum);cout<<“停车场已满,请在便道等候!”< break;}a.Push(n);cout<<“请输入进入时间: ”;cin>>time[t1];while(time[t1]<0||time[t1]>=24){cout<<“请输入正确的时间(0~23时):”; cin>>time[t1];}t1++;}catch(char*s){cout<break;case 2:try{int n2;//离开车辆的编号cout<<“请输入要离开的车的位置: ”; cin>>n2;if(a.Count()+1==0){cout<<“该停车场没有车辆,请选择其他操作!”; break;}elsewhile(n2<1||n2>a.Count()+1){cout<<“请输入1~”<cin>>n2;}int j=a.Count();for(int i=0;i<(j+1-n2);i++)b.Push2(a.Pop(n2));a.Pop(n2);int j2=b.Count();for(int i1=0;i1<=j2;i1++)a.Push(b.Pop(n2));int j3=c.Count();int time1;cout<<“请输入离开时间: ”;cin>>time1;while(time1<0||time1>23){cout<<“请输入正确的时间(0~23时): ”;cin>>time1;}int day=0;if(time1{cout<<“离开时间已小于进入时间!请加上停留天数(天):”;cin>>day;while(day<=0){cout<<“输入的天数必须大于0：”;cin>>day;}}cout<<“您的费用是(元): ”<<(time1-time[n2-1]+24*day)*money<for(int i2=0;i2<(j+1-n2);i2++)time[n2-1+i2]=time[n2+i2];t1--;if(j3!=0){a.Push(c.DeQueue());cout<<“ttt通知: 便道车辆请进入停车场!”<cout<<“请输入进入时间: ”;cin>>time[t1];while(time[t1]<0||time[t1]>=24){cout<<“请输入正确的时间(0~23时):”;cin>>time[t1];}t1++;}}catch(char *s){cout<break;case 3:a.PrintStack();break;case 4:int n3;cout<<“请输入离开车辆的车牌号: ”;cin>>n3;try{c.xzDeQueue(n3);}catch(char*s){cout<break;case 5:cout<<“请输入单价: ”;cin>>money;cout<<“修改成功!”<cout<<“当前停车场的费用是:”<break;case 6:xh1=0;break;} } system(“pause”);}心得体会:完成时间:2010-10-30第二篇：实验三栈和队列实验报告三栈和队列班级：姓名：学号：专业：一、实验目的：（1）掌握栈的基本操作的实现方法。
停车场管理摘要栈和队列是运算受限的线性表，它们被广泛地应用于各种程序设计中。
在停车场管理问题中，通过使用顺序栈模拟停车场，链队列模拟车场外的便道，实现车辆入栈，出栈，入队列，出队列，信息输出等功能。
用两个堆栈来分别模拟停车场以及停车场内车辆为其它车辆让路时退出停车的临时停放地点。
至于通道上车辆的停放则用一个链队列来实现，此时，通道上车辆的离开或者进入停车场只需改变此链队列上的结点。
对于要对停车场内的车辆根据其停放时间收取相应的停车费用，可以记录下车辆进入以及离开停车场的时间，再用时间差乘以相应的单价即可。
使用顺序栈存放进入车场的车辆，链队列存放有关车场外便道的情况，通过此程序的编写及运行，深刻理解线性表和栈的逻辑结构，存储结构，掌握线性表和栈上基本运算的实现。
关键词：顺序栈；链队列；停车场THE OPERATOR ORDERING PROBLEM IN QUANTUM HAMITONIAN FOR SOME CONSTRAINT SYSTEMSABSTRACTAccording to surface theory in differential geometry, the two-dimensional surface is parameterized by two variables. This is, when a particle moves on the surface, only two variables suffice to describe the motion of the particle. …………Key words: quantum mechanics; operator ordering; Hermitian operator; canonicalquantization; gauge transformation三号Times New Roman 居中加黑，一律用大写字母，上下各空一行。
栈与队列的应⽤：停车场管理设停车场是⼀个可停放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); }}运⾏结果：。
C语言栈和队列综合应用停车场模拟-栈和队列综合应用假设停车场是一个宽度只能停放一辆汽车的狭长通道，只有一个大门可供汽车进出。
汽车在停车场内按到达的先后顺序依次排列，若车场内已停满汽车，则新到达的汽车只能在门外的便道上等候（假设便道无限长），一旦停车场内有汽车离场，则排在便道上的第一辆汽车即可进入；当停车场内某辆汽车要离场时(假设只有进入停车场的汽车才能离场)，由于停车场是狭长的通道，在它之后进场的汽车必须先退出车场让路，待离场汽车离开停车场后，让路的汽车再按原次序进入车场。
请编写程序模拟对上述停车场的管理。
注意：1.车辆信息自定义2.程序功能需使用栈和队列的基本操作实现3.栈使用顺序存储结构，队列使用链式存储结构4.要求能够模拟车辆进场、车辆离开及查看停车场的信息#include#include#include#define MAXSIZE 3//类型定义typedef int datatype;// 1)顺序栈typedef struct{datatype data_1[MAXSIZE];int top;}SeqStack;// 2)链式队列typedef struct nodedatatype data_2;struct node *next;}QNode;typedef struct{QNode *front,*rear;}LQueue;//顺序栈的基本操作//1.置空栈SeqStack *Init_SeqStack(){SeqStack *s;s=(SeqStack *)malloc(sizeof(SeqStack));s->top=-1;return s;}//2.入栈int Push_SeqStack(SeqStack *s,datatype x) { if(s->top==MAXSIZE-1)return 0; //栈满不能入栈else{s->top++;s->data_1[s->top]=x;return 1; //入栈成功返回1}}//3.判空栈int Empty_SeqStack(SeqStack *s)if(s->top==-1)return 1;elsereturn 0;}//4.出栈int Pop_SeqStack(SeqStack *s,datatype x) { if(Empty_SeqStack(s)==-1)return 0; //栈空不能出栈else{x=s->data_1[s->top];s->top--;return 1;}}//5.取出栈顶元素datatype Top_SeqStack(SeqStack *s){if(Empty_SeqStack(s)==-1)printf("SeqStack is empty\n"); //空栈else return s->data_1[s->top];}//链式队列的基本操作//1.创建一个带头结点的空队列LQueue *Init_LQueue(){LQueue *q;QNode *p;q=(LQueue *)malloc(sizeof(LQueue)); p=(QNode *)malloc(sizeof(QNode)); p->next=NULL;q->front=q->rear=p;return q;}//2.入队列void In_LQueue(LQueue *q,datatype x) {QNode *p;p=(QNode *)malloc(sizeof(QNode)); p->data_2=x;p->next=NULL;q->rear->next=p;q->rear=p;}//3.判队列空int Empty_LQueue(LQueue *q){if(q->front==q->rear)return 0;elsereturn 1;}//4.出队列int Out_LQueue(LQueue *q){QNode *p;if(Empty_LQueue(q)==0){printf("队列空\n");return 0;}else{p=q->front->next;q->front->next=p->next;free(p);if(q->front->next==NULL)q->rear=q->front; //如果只有一个元素时，出队后队空，此时还需要修改队尾指针return 1;}}//功能实现//1.插入停车信息void Insert_stop(SeqStack *s,LQueue *q){int i;datatype x;printf("Enter Car No:");scanf("%d",&x);i=Push_SeqStack(s,x);if(i==0) //如果栈满，返回值为0，表示停车位已满{In_LQueue(q,x);printf("car %d is waiting\n",q->rear->data_2);}if(i==1) //如果入栈成功，返回值为1，表示车进入成功{printf("car %d is entring\n",s->data_1[s->top]);}}//车辆离开停车位void leaving(SeqStack *s,LQueue *q){datatype x;SeqStack *t=Init_SeqStack();int i,j,k=0;if(s->top==-1) //如果车位是空的printf("parking is empty\n");else //如果车位不是空的{printf("Leave car NO:");scanf("%d",&x);if(s->data_1[s->top]==x) //如果要离开的车是最后一辆进来的车{i=Pop_SeqStack(s,s->data_1[s->top]); //最后一辆车离开if(q->front->next){i=Push_SeqStack(s,q->front->next->data_2); //等待的车进去printf("Car %d is entring\n",q->front->next->data_2);j=Out_LQueue(q);}printf("Car %d is leaving\n",x);}else //如果要离开的车不是最后一辆进来的车{while(s->data_1[s->top]!=x)printf("Car %d is giving way\n",s->data_1[s->top]);i=Push_SeqStack(t,s->data_1[s->top]); //车退到临时停车位j=Pop_SeqStack(s,s->data_1[s->top]); //删除停车位中退到临时停车位的车辆信息if(s->top==-1) //如果没有查找到要离开的车辆信息{printf("Input error\n");k=1;break;}}if(k==0) //如果找到了要离开的{j=Pop_SeqStack(s,s->data_1[s->top]); //需要离开的那一辆车离开printf("Car %d is leaving\n",x);}if(s->data_1[s->top]!=x) //退到临时停车位的车辆重新回到停车位内{while(t->top!=-1){printf("Car %d is reentring\n",t->data_1[t->top]);i=Push_SeqStack(s,t->data_1[t->top]);j=Pop_SeqStack(t,t->data_1[t->top]);}}if(q->front->next&&k!=1) //候车区的车进去如果；k==1说明没有查到要离开的车，候车区的车不会进入i=Push_SeqStack(s,q->front->next->data_2);printf("Car %d is entring\n",q->front->next->data_2); j=Out_LQueue(q);}}}}//车辆信息void print_Car(SeqStack *s,LQueue *q){int i;QNode *p;printf("Car is parking:\n");for(i=0;i<=s->top;i++){printf("\t%d",s->data_1[i]);}printf("\nCar is waiting:\n");p=q->front->next;while(p!=NULL){printf("\t%d",p->data_2);p=p->next;}printf("\n");}//退出void Destroy_SeqStack(SeqStack **s){if(*s)free(*s);*s=NULL;}void Destroy_LNode(LQueue *q) {QNode *t1,*t2;t1=q->front->next;while(t1){t2 = t1;t1 = t1->next;free(t2);}if(t1==NULL)printf("销毁成功，请退出\n"); elseprintf("销毁失败\n");}//main函数void printChoice(){printf("\nOptions：\n");printf("\t1.Car come\n");printf("\t2.Car leave\n");printf("\t3.Show cars\n");printf("\t4.Exit\n");}int main(){SeqStack *s=Init_SeqStack(); LQueue *q=Init_LQueue(); int choice=-1;while(1){printChoice();scanf("%d",&choice); switch(choice){case 1:Insert_stop(s,q);break;case 2:leaving(s,q);break;case 3:print_Car(s,q);break;case 4:Destroy_SeqStack(&s); Destroy_LNode(q);exit(0);break;default:printf("input error\n"); break;}}}。
栈和队列的综合应用实例-程序实现实验二的作业题// sy23.cpp : 停车场管理的简单模拟.#include"stdafx.h" //标准应用程序框架的扩展,stdafx.h中没有函数库，只是定义了一些环境参数，使得编译出来的程序能在32位的操作系统环境下运行。
#include<stdio.h> //标准输入输出头文件, 如常用的主要有：scanf和printf、gets和puts、getchar和putchar#include"stdlib.h" //标准库头文件stdlib头文件，里包含了C、C语言的最常用的系统函数，如malloc() #include<conio.h> //控制台输入输出)的简写，主要是一些用户通过按键盘产生的对应操作，比如getch()#define N 4 /* 停车场容量*/#define M 5 /* 收费单价/单位时间*/#define True 1#define False 0#define Null 0typedef struct element {int num;int arrtime;} ElemType;typedef struct stacktag {ElemType stack[N];int top;} STACK;typedef struct nodetag {int num;struct nodetag *next;} QUEUE;typedef struct queuetag {QUEUE *front,*rear;}LinkedQueTp;void InitStack(STACK &s);int Push(STACK &s,ElemType e);int Pop(STACK &s,ElemType &e);void initLQ(LinkedQueTp &q);void enQueueLQ(LinkedQueTp &q,int e);int deQueueLQ(LinkedQueTp &q,int &e);void Arrive(STACK &s1,LinkedQueTp &q,ElemType e);void Delive(STACK &s1,STACK &s2,LinkedQueTp &q,ElemType e);void InitStack(STACK &s) {s.top=-1;}int Push(STACK &s,ElemType e) {if(s.top==N-1) {printf("\n栈满，入栈操作失败!\n");return(False);}s.stack[++s.top]=e;return(True);}int Pop(STACK &s,ElemType &e) {if(s.top==-1) {e.num=Null;e.arrtime=Null;return(False);}e=s.stack[s.top--];return(True);}void initLQ(LinkedQueTp &q) {QUEUE *p=(QUEUE *)malloc(sizeof(QUEUE));p->num=0;p->next=NULL;q.front=q.rear=p;}void enQueueLQ(LinkedQueTp &q,int e) {QUEUE *p=(QUEUE *)malloc(sizeof(QUEUE));p->num=e;p->next=NULL;q.rear->next=p;q.rear=p;q.front->num++;//头节点数据域存放车数量}int deQueueLQ(LinkedQueTp &q,int &e) {if(q.rear == q.front) {e=0;return 0;}QUEUE *p=q.front->next;e=p->num;q.front->next=p->next;if(p->next==NULL) q.rear=q.front;free(p);q.front->num--;return 1;}void Arrive(STACK &s1,LinkedQueTp &q,ElemType e) {/* 车辆到达处理*/ int f,no1,no2;f=Push(s1,e);/* 新到车辆进入停车场栈 */if(f==False) { /* 如停车场满, 就进入便道队列等待*/enQueueLQ(q,e.num);no1=q.front->num;printf("第%d号车停在便道的第%d号车位上\n",e.num,no1); } else { /* 新到车辆进入停车场*/no1=s1.top+1;no2=e.num;printf("第%d号车停在停车场的第%d号车位上\n",no2,no1); }} /* Arrive */void Delive(STACK &s1,STACK &s2,LinkedQueTp &q,ElemType e) {/* 离开处理*/ int n,f=False;ElemType y;QUEUE *p;while((s1.top>-1) && (f!=True)) {/* 在停车场中寻找要离开的车辆*/Pop(s1,y);if(y.num!=e.num) /* 如果栈顶元素不是要离开的车辆,就将其放入车辆规闭所*/ n=Push(s2,y);else f=True;}if(y.num==e.num) { /*在停车场中找到要离开的车辆*/printf("第%d号车应收费%d元",y.num,(e.arrtime-y.arrtime)*M);while(s2.top>-1) {Pop(s2,y);f=Push(s1,y);}deQueueLQ(q,n);if(n!=Null) { /* 有车在队列中等待*/y.num=n;y.arrtime=e.arrtime;f=Push(s1,y);printf("第%d号车停在停车场第%d号车位上\n",y.num,s1.top+1);}}else { /*在停车场中没有找到要离开的车辆*/while(s2.top>-1) {Pop(s2,y);f=Push(s1,y);}p=q.front; /* 指向队头*/f=False;while(f==False && p->next !=Null) /*在便道上寻找要离开的车辆*/if(p->next->num!=e.num) p=p->next;else {p->next=p->next->next; /*在便道上找到该车辆*/q.front->num--;if(p->next==Null) q.rear=q.front;printf("第%d号车离开便道\n",e.num);/*该车离开便道,但不收费*/f=True;}if(f==False)printf("输入数据错误,停车场和便道上均无第%d号车\n",e.num);}}int _tmain(int argc, _TCHAR* argv[]) { /* 停车场模拟管理程序 */ char ch1,ch2;STACK s1,s2;LinkedQueTp q;ElemType x;int flag,t1,t2;InitStack(s1); /* 初始化停车场栈 */InitStack(s2); /* 初始化车辆规避所栈 */initLQ(q); /* 初始化便道队列 */flag=True;for(;;) {system("cls");printf("\n输入数据：'A'/'D',车牌号，到达时间/离开时间\n");printf("E---退出。
数据结构用栈和队列创建停车场管理系统实验报告一、实验背景及目的随着城市化进程的不断加速，车辆数量急剧增长，停车难成为了城市发展中的一个重要问题。
为了解决这一问题，需要建立高效的停车场管理系统。
数据结构中的栈和队列是常用的数据结构，可以用来创建停车场管理系统。
本次实验旨在通过使用栈和队列来创建一个停车场管理系统，并测试其功能。
二、实验原理及方法1. 停车场管理系统基本原理停车场管理系统主要包括三个部分：入口、出口和停车位。
当车辆到达入口时，需要检查是否有空余的停车位；如果有，则将其分配一个位置并记录下来；否则，需要让其等待直到有空余位置。
当车辆离开时，需要释放该位置并更新记录。
2. 使用栈和队列创建停车场管理系统（1）使用栈来模拟停车位由于每个停车位只能容纳一辆汽车，可以使用栈来模拟每个停车位。
当有新的汽车进入时，将其压入栈中；当汽车离开时，则将其从栈中弹出。
（2）使用队列来模拟等待区由于等待区可以容纳多辆汽车，可以使用队列来模拟等待区。
当有新的汽车到达时，将其加入队列尾部；当有车位空余时，则从队列头部取出一辆汽车进入停车场。
3. 实验步骤（1）创建停车场管理系统的数据结构：使用栈和队列分别来模拟停车位和等待区。
（2）实现停车场管理系统的基本操作：包括汽车进入、离开、查询空余停车位等操作。
（3）测试停车场管理系统的功能：模拟多辆汽车进出停车场，检查系统是否能够正确地分配和释放停车位，并且能够正确地记录空余停车位数。
三、实验结果与分析本次实验使用栈和队列创建了一个简单的停车场管理系统，并测试了其基本功能。
在测试过程中，我们模拟了多辆汽车进出停车场，并检查了系统能否正确地分配和释放停车位。
实验结果表明，该系统可以正常工作，并且能够正确地记录空余停车位数。
四、实验总结通过本次实验，我们学习了如何使用栈和队列来创建一个简单的停车场管理系统。
同时，我们也深刻认识到数据结构在实际应用中的重要性。
在今后的学习中，我们将继续深入学习数据结构，并探索其更广泛的应用。
经过这么长的时间，我终于编完了这个，在我成功输出的时候，有种巨大的愉快感与成就感充斥我心中；这个程序使用两个栈s1与s2，还有一个队列Q，包含了栈/队列的构建、栈/队列的初始化、删除栈顶/对头元素、插入栈顶/队尾元素等操作，让我对栈与队列的理解加深了很多这个程序最难的的部分是对停车场进行管理操作部分的函数--即下面的Ye（）函数，调试该函数花了我最长的时间，不过在一步一步的调试过程中也有一种难言的快乐，在调试的时候，我逐渐理解到了更深层次的东西，对我的编程能力提升很大以下是截图：以下是程序：#include<iostream>using namespace std;#define stack_init_size 100 //存储空间初始分配量#define stackincreament 10 //存储空间增量typedef struct {int time;int num;}car;typedef struct { //栈的存储结构car *base; //栈低指针car *top; //栈顶指针int stacksize; //当前已分配的存储空间}sqstack;typedef struct qnode{ //队列的节点int data1,data2; //数据域struct qnode *next; //指针域}qnode,*qptr;typedef struct { //队列指针qptr front; //对头指针qptr rear; //对尾指针}linkq;void initstack(sqstack &s) //构建空栈{s.base=(car *)malloc(stack_init_size*sizeof(int)); //动态存储分配栈低指针s.top=s.base; //栈为空s.stacksize=stack_init_size; //初始存储空间分配}void push(sqstack &s,int num,int time) //插入新的栈顶元素{if(s.top-s.base>=s.stacksize) //栈满，追加存储空间{s.base=(car*)realloc(s.base,(s.stacksize+stackincreament)*sizeof(int));if(!s.base) exit(-1);s.top=s.base+s.stacksize;s.stacksize+=stackincreament;}s.top++;s.top->num=num;s.top->time=time;}void pop(sqstack &s) //删除栈顶元素{if(s.top==s.base)return;s.top--;}int length(sqstack &s) //求栈的长度{int length;length=s.top-s.base;return length;}void initq(linkq &Q) //构建空队列{Q.front=Q.rear=(qptr)malloc(sizeof(qnode)); //动态存储分配if(!Q.front) exit(-1);Q.front->next=NULL; //构建空队列}void enq(linkq &Q,int e1,int e2 ) //插入新的队尾元素{qptr p=(qptr)malloc(sizeof(qnode));if(!p) exit(-1);p->data1=e1;p->data2=e2;p->next=NULL;Q.rear->next=p;Q.rear=p;}void deq(linkq &Q) //删除对头元素{qptr p=Q.front->next;Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;free(p);}void Ye(sqstack &s1,sqstack &s2,linkq &Q,int n)//实现停车场管理的各种操作{char A;int num;int time;int yuan=1;cout<<"请输入:";cin>>A>>num>>time;if(A=='A'){if(length(s1)<n){cout<<"停车场上有的车辆数:"<<length(s1)+1<<endl;push(s1,num,time);}else{enq(Q,num,time);cout<<"这两车停在便道上"<<endl;}}else if(A=='D'){if(num==s1.top->num){yuan=100*(time-s1.top->time);cout<<"你需要支付的停车费是："<<yuan<<"元"<<endl;pop(s1);if(Q.front->next!=NULL){push(s1,Q.front->data1,Q.front->data2);deq(Q);}}else if(num==(s1.top-1)->num){while(num!=s1.top->num){push(s2,s1.top->num,s1.top->time);pop(s1);}yuan=100*(time-s1.top->time);cout<<"你需要支付的停车费是："<<yuan<<"元"<<endl;pop(s1);push(s1,s2.top->num,s2.top->time);pop(s2);if(Q.front->next!=NULL){push(s1,Q.front->data1,Q.front->data2);deq(Q);}}elsecout<<"车子在便道上，此时不收费"<<endl;}elsecout<<"错误"<<endl;}void main(){cout<<"停车场管理"<<endl;cout<<"本停车场每小时收费100元"<<endl;int n;cout<<"请输入停车场的承载上限：";cin>>n;cout<<"本停车场只能放n辆车:n="<<n<<endl;cout<<"请按以下格式输入以管理停车场"<<endl;cout<<"车辆进出标志（AorD）车辆牌照号码车辆进站或出战时间"<<endl;cout<<"D——车辆离开停车场 A——车辆进入停车场"<<endl;sqstack s1,s2;initstack(s1);initstack(s2);linkq Q;initq(Q);while(100){cout<<"请按E或C，C表示输入，E表示退出:";char Y;cin>>Y;if(Y=='E'){cout<<"已经安全退出"<<endl;break;}else if(Y=='C'){Ye(s1,s2,Q,n);}elsecout<<"错误"<<endl;}}。
实验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个位置。
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.主程序模块处理过程描述首先输入该车辆信息，判断是否是输入结束标志，是则跳出循环，否则判断是否是进入的车辆，如果是进入的车辆，那么判断此时栈是否已经满了，如果此时栈已满，那么该车辆就要入队列，否则入栈。
实验二：停车场管理（栈和队列应用）班级学号姓名一、实验目的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．学会了栈和队列的综合使用，更加灵活运用栈和队列。
华北水利水电学院数据结构实验报告2012～2013学年第一学期2010级计算机科学与技术专业班级：2010136 学号：201013624 姓名：柴有为实验二栈和队列及其应用一、实验题目：栈和队列及其应用——停车场管理二、实验内容：设停车场是一个可停放n辆车的狭长通道，且只有一个大门可供汽车进出。
汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北段），若停车厂内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车迹可开入；停车场内某辆车要离开时，在它之后进入的车连必须先退出车厂为它让路，待该车辆开出大门外，其他车辆再按原次序进入车场，每辆停放在车场的车在它离开停车时必须按它停留的时间长短缴纳费用。
编写按上述要求进行管理的模拟程序。
可以将停车场定义成一个顺序栈s0，便道定义成一个链队列q，而停车场中的某辆车要离开，则在它后面进停车场的车必须让道，让其离开，所以必须有一个临时的顺序栈s1，存放让道的车辆。
当有车辆进停车场时，若栈s0不满，则直接进入栈s0；若栈s0满，则进入便道（链队列q）。
若有s0中车辆x离开时，先让在x后面进栈的车从s0退栈并进入栈s1中，让x离开并收取停车费（在便道上停留的时间不收费），然后再把s1中所有元素退栈并重新进入s0栈，最后，将链队列q中的队头元素出队并进栈到s0中。
三、程序源代码：#include<stdio.h>#include<time.h>#include<stdlib.h>typedef struct{long* base;long* top;int stacksize;}SqStack;typedef struct QNode{long data;struct QNode* next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;int lenth;}LinkQueue;bool InitStack(SqStack &S,int capacity){S.base=(long*)malloc(10 * sizeof(long));if(!S.base)exit(1);S.top=S.base;S.stacksize=capacity;return 1;}//InitStackbool Push(SqStack &S,long e){if(S.top-S.base>=S.stacksize){S.base=(long*)realloc(S.base,(S.stacksize+10)*sizeof(long));if(!S.base)exit(1);S.top=S.base+S.stacksize;S.stacksize+=10;}*S.top++=e;return 1;}//Pushbool Pop(SqStack &S,long &e){if(S.top==S.base) return 0;e=*--S.top;return 1;}//Popbool InitQueue(LinkQueue &Q){Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.front)exit(1);Q.front->next=NULL;Q.lenth=0;return 1;}bool EnQueue(LinkQueue &Q,long e){QueuePtr p;p=(QueuePtr)malloc(sizeof(QNode));if(!p)exit(1);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;Q.lenth++;return 1;}bool DeQueue(LinkQueue &Q,long &e){QueuePtr 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);Q.lenth--;return 1;}void park(SqStack &a,LinkQueue &b,int capacity) {if((a.top-a.base)<capacity){time_t t1;time(&t1);Push(a,t1);printf("停车成功,车位号%d\n",a.top-a.base);}else{printf("停车场已满，进入便道\n");EnQueue(b,0);}}void leave(SqStack &a,SqStack &s,int b,int 单价) {long* t=a.base+b-1;if(t>=a.top||t<a.base){printf("该车位没有车辆\n");return;}else{long* p;long e;long rt;time_t n;time(&n);long* p1=a.base+b;for(p=a.top;p>p1;p--){Pop(a,e);Push(s,e);}Pop(a,e);rt=difftime(n,e);printf("停车时间为%d秒,应交费%lf元\n",rt,(double)(rt)*单价/3600);for(p=s.top;p>s.base;p--){Pop(s,e);Push(a,e);}}}void WaitingCarEnter(SqStack &a,LinkQueue &b){long e;DeQueue(b,e);Push(a,e);printf("便道车进站\n");}void SetPrice(double &a){while(true){printf("请设定单价（元/小时）：");scanf("%lf",&a);getchar();if(a>0){printf("单价为%lf元/小时\n",a);break;}elseprintf("输入值无效！\n");}}void SetCapacity(int &a){while(true){printf("当前停车场容量为%d,请设定容量：",a);scanf("%d",&a);getchar();if(a>0){printf("当前容量为:%d\n",a);break;}elseprintf("输入值无效！\n");}}void main(){char a;int n;int capacity=5;double 单价;SqStack s0,s1;LinkQueue q;InitStack(s0,capacity);InitStack(s1,capacity);InitQueue(q);printf("----------停车场管理程序----------\n");printf("命令：p停车，l取车，g停车数量，e停车场扩容，s重设单价，c清空屏幕\n");SetPrice(单价);while(true){printf("请输入命令：");a=getchar();getchar();switch(a){case 'P':case 'p':park(s0,q,capacity);break;case 'L':case 'l':printf("请输入取车车位号:");scanf("%d",&n);getchar();leave(s0,s1,n,单价);break;case 'G':case 'g':printf("当前场内停有%d辆车，便道内有%d辆车\n",s0.top-s0.base,q.lenth);break;case 'S':case 's':SetPrice(单价);break;case 'E':case 'e':SetCapacity(capacity);break;case 'C':case 'c':system("cls"); printf("----------停车场管理程序----------\n");printf("命令：p停车，l取车，g停车数量，e设置容量，s重设单价，c清空屏幕\n");break;}while(q.front!=q.rear&&s0.top-s0.base<capacity){WaitingCarEnter(s0,q);}}getchar();}四、测试结果：五、小结（包括收获、心得体会、存在的问题及解决问题的方法、建议等）这次试验运用了栈和队列的知识，利用栈和队列的相关方法，方便地实现了一个停车场的管理程序，实验过程中发现了自己对栈和队列的理解不够深刻，通过这次实验，加深了自己的理解，提高了自己的实践能力。
