栈和队列及其应用 停车场管理
实验二栈和队列实验报告---停车场问题
数据结构实验报告实验二栈和队列实验班级：计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;}实验结果截图：。
栈和队列的应用停车场管理
free(q);
}
else
printf("\n便道里没有车！");
}
else
printf("\n现在停车场里没有车了！");
}
//打印输出地信息
{
printf("\n等待车辆的号码为：");
while(p!=NULL)
{
puts(p->data->num);
p=p->next;
}
}
else
printf("\n便道里没有车！");
printf("该车离去的时间：%d:%d。",p->leave.hour,p->leave.min);
a1=p->reach.hour;
a2=p->reach.min;
d1=p->leave.hour;
d2=p->leave.min;
printf("收取的费用：%2.1f元",((d1-a1)*60+(d2-a2))*price);
{
qnode *head;
qnode *rear;
}linkqueue;
//栈的初始化
void initstack(carstack *s)
{
int i;
s->top=0;
for(i=0;i<=MAX;i++)
s->stack[s->top]=NULL;
}
void list(carstack s,linkqueue w)
实验三栈和队列的应用
实验三栈和队列的应用第一篇：实验三栈和队列的应用一、实验目的掌握栈的数据类型描述及栈的特点；掌握栈的顺序存储结构的特点及算法描述；掌握队列的数据类型描述及链式存储结构的特点和算法描述。
二、实验内容停车场管理。
设有一个可以停放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）掌握栈的基本操作的实现方法。
栈与队列的应用：停车场管理
栈与队列的应⽤：停车场管理设停车场是⼀个可停放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;}四、测试结果：五、小结（包括收获、心得体会、存在的问题及解决问题的方法、建议等）车进站这个实验花费了我相当多的时间，虽然老师给了我们做题的思路，但由于我栈的内容没学扎实，因此在计算停车时间的时候遇到了不能解决的问题，后来参考了网上的做法才知道栈里面可以存放节点，这个问题才得以解决。
C语言栈和队列综合应用
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;}}}。
第2章-2-栈和队列的应用举例(停车场管理)-程序分析
栈和队列的综合应用实例-程序实现实验二的作业题// 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）测试停车场管理系统的功能：模拟多辆汽车进出停车场，检查系统是否能够正确地分配和释放停车位，并且能够正确地记录空余停车位数。
三、实验结果与分析本次实验使用栈和队列创建了一个简单的停车场管理系统，并测试了其基本功能。
在测试过程中，我们模拟了多辆汽车进出停车场，并检查了系统能否正确地分配和释放停车位。
实验结果表明，该系统可以正常工作，并且能够正确地记录空余停车位数。
四、实验总结通过本次实验，我们学习了如何使用栈和队列来创建一个简单的停车场管理系统。
同时，我们也深刻认识到数据结构在实际应用中的重要性。
在今后的学习中，我们将继续深入学习数据结构，并探索其更广泛的应用。
(完整word版)数据结构-链队列和停车场(word文档良心出品)
数据结构与算法课程实验报告实验二：栈和队列的应用姓名：***班级：14信息与计算科学（2）班学号：*************实验二 栈和队列的应用【实验内容】一、实现链队列（带头结点）的各种基本运算二、停车场管理【实验目的】掌握栈和队列的定义和实现，学习利用栈和队列解决实际问题。
【问题描述】一、问题描述：1）初始化并建立链队列2）入队列3）出队列二、问题描述：设停车场内只有一个可停放n 辆汽车的狭长通道，且只有一个大门可供汽车进出。
汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满n 辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后开入的车辆必须先退出车场为它让路，待该辆车开出大门外，其它车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。
分析:以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。
每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时刻，对每一组输入数据进行操作后的输出数据为：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车离去；则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。
栈以顺序结构实现，队列以链表实现。
需另设一个栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车，也用顺序存储结构实现。
输入数据按到达或离去的时刻有序。
栈中每个元素表示一辆汽车，包含两个数据项：汽车的牌照号码和进入停车场的时刻。
设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）。
栈和队列及其应用_停车场管理
实验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.同时，还需要将这辆车按到达的时间加入到队列中，便于后续的管理。
4.最后，还需要更新停车场的剩余车位数，并将结果写入数据库中。
离开停车场当一辆车在完成缴费后离开停车场时，需要执行以下操作：1.首先，需要从栈中出栈，将车辆的信息拿出来。
2.然后，需要将这辆车从队列中删除，避免干扰后续车辆的出场。
3.接着，需要更新停车场的剩余车位数，将车位数加一，并将结果写入数据库中。
数据结构 停车场管理报告
实验二：停车场管理（栈和队列应用）班级学号姓名一、实验目的1 掌握队列和栈顺序存储结构和链式存储结构，以便在实际背景下灵活运用。
2 掌握栈和队列的特点，即先进后出与先进先出的原则。
3 掌握栈和队列的基本运算。
二、实验内容1 问题描述设有一个可以停放n辆汽车的狭长停车场，它只有一个大门可以供车辆进出。
车辆按到达停车场时间的早晚，依次从停车场最里面向大门口处停放。
如果停车场已放满n辆车，则后来的车辆只能在停车场大门外的便道上等待，一旦停车场内有车开走，则排在便道上的第一辆车就进入停车场。
停车场内如有某辆车要开走，在它之后进入停车场的车都必须退出停车场为它让路，待其开出停车场后，这些车辆再依原来的次序进场。
每辆车在离开停车场时，都应根据它在停车场内停留的时间长短来交费。
如果停留在便道上的车未进入停车场就要离去，允许其离开，不收停车费，并且仍然保持在便道上等待的车辆次序。
编制一个程序模拟该停车场的管理。
2 实现要求要求程序输出每辆车到达后的停车位置（停车场或便道），以及某辆车离开停车场时应该交纳的费用和它在停车场内停留的时间。
3 实现提示汽车的模拟输入信息格式可以为：（到达/离开，汽车牌照号码，到达/离开的时间）。
用栈和队列来模拟停车场和便道。
三、实验结果：头文件#define MAXSIZE 3#define price 0.4typedef struct time {int hour;int min;}Time;typedef struct car {char num[10];Time reach;Time leave;}CarNode;typedef struct SNode {CarNode *data1[MAXSIZE+1];int top;}SeqStackCar;typedef struct QNode {CarNode *data2;struct QNode *next;}QueueNode;typedef struct LQNode {QueueNode *front;QueueNode *rear;}LinkQueueCar;void InitStack(SeqStackCar *s);int InitQueue(LinkQueueCar *Q);void Display(CarNode *p,int place);int Arrival(SeqStackCar *s,LinkQueueCar *LQ);void Leave1(SeqStackCar *s1,SeqStackCar *s2,LinkQueueCar *LQ); void Leave2(LinkQueueCar *LQ);void List1(SeqStackCar *s);void List2(LinkQueueCar *LQ);源文件#include "car.h"#include<iostream>using namespace std;int i=0;void InitStack(SeqStackCar *s){int i;s->top=0;for(i=0;i<=MAXSIZE;i++)s->data1[s->top]=NULL;}int InitQueue(LinkQueueCar *Q){Q->front=new QueueNode;if(Q->front!=NULL){Q->front->next=NULL;Q->rear=Q->front;return 1;}elsereturn 0;}void Display(CarNode *p,int place){int A1,A2,B1,B2,time;cout<<"请输入离开的时间:";cin>>p->leave.hour;cin>>p->leave.min;while(p->leave.hour<p->reach.hour||p->leave.hour>23){cout<<"error!"<<endl;cout<<"请输入离开的时间:";cin>>p->leave.hour;cin>>p->leave.min;}cout<<endl;cout<<"离开车辆的车牌号为:";cout<<p->num<<endl;cout<<"其到达时间为: "<<p->reach.hour<<":"<<p->reach.min<<endl;cout<<"其离开时间为: "<<p->leave.hour<<":"<<p->leave.min<<endl;A1=p->reach.hour;A2=p->reach.min;B1=p->leave.hour;B2=p->leave.min;time=(B1-A1)*60+(B2-A2);cout<<"该车停在停车场中的时间:"<<time<<"分钟!"<<endl;cout<<"应交费用为: "<<time*price<<"元!"<<endl;cout<<endl;}int Arrival(SeqStackCar *s,LinkQueueCar *LQ){CarNode *p;QueueNode *t;p=new CarNode;cout<<"请输入车牌号(例:A1234):";cin>>p->num;if(s->top<MAXSIZE){s->top++;cout<<"车辆在车场第"<<s->top <<"位置!"<<endl;cout<<"请输入到达时间:";cin>>p->reach.hour;cin>>p->reach.min;while(p->reach.hour<0||p->reach.hour>23||p->reach.min<0||p->reach.min>59) {cout<<"error!"<<endl;cout<<"请输入到达时间:";cin>>p->reach.hour;cin>>p->reach.min;}s->data1[s->top]=p;return 1;}else{cout<<"该车停在便道上!"<<endl;t= new QueueNode;t->data2=p;t->next=NULL;LQ->rear->next=t;LQ->rear=t;i++;cout<<"车辆在便道"<<i<<"个位置!"<<endl;return 1;}}void Leave1(SeqStackCar *s1,SeqStackCar *s2,LinkQueueCar *LQ) {int place;CarNode *p,*t;QueueNode *q;if(s1->top>0){while(1){cout<<"请输入车在车场的位置1--"<<s1->top<<":";cin>>place;if(place>=1&&place<=s1->top) break;}while(s1->top>place){s2->top++;s2->data1[s2->top]=s1->data1[s1->top];s1->data1[s1->top]=NULL;s1->top--;}p=s1->data1[s1->top];s1->data1[s1->top]=NULL;s1->top--;while(s2->top>=1){s1->top++;s1->data1[s1->top]=s2->data1[s2->top];s2->data1[s2->top]=NULL;s2->top--;}Display(p,place);if((LQ->front!=LQ->rear)&&s1->top<MAXSIZE){q=LQ->front->next;t=q->data2;s1->top++;cout<<"便道的"<<t->num<<"号车进入车场第"<<s1->top<<"位置!"<<endl;cout<<"请输入到达的时间:";cin>>t->reach.hour;cin>>t->reach.min;if(t->reach.hour<0||t->reach.hour>23||t->reach.min<0||t->reach.min>59){cout<<"error!"<<endl;cout<<"请输入到达时间:";cin>>t->reach.hour;cin>>t->reach.min;}LQ->front->next=q->next;if(q==LQ->rear)LQ->rear=LQ->front;s1->data1[s1->top]=t;delete q;}elsecout<<"便道里没有车!"<<endl;}elsecout<<"停车场里没有车!"<<endl;}void Leave2(LinkQueueCar *LQ){QueueNode *q;CarNode *t;if(LQ->front!=LQ->rear){q=LQ->front->next;t=q->data2;LQ->front->next=q->next;if(q==LQ->rear)LQ->rear=LQ->front;delete q;cout<<"便道上车牌号为"<<t->num<<"的车从便道上离开!"<<endl;}elsecout<<"便道里没有车!"<<endl;}void List1(SeqStackCar *s){int i;if(s->top>0){cout<<" 位置到达时间车牌号"<<endl;for(i=1;i<=s->top;i++){cout<<" "<<i<<" "<<s->data1[i]->reach.hour<<":"<<s->data1[i]->reach.min<<" "<<s->data1[i]->num<<endl;}}elsecout<<"停车场里没有车!"<<endl;}void List2(LinkQueueCar *LQ){QueueNode *p;p=LQ->front->next;if(LQ->front!=LQ->rear){cout<<"便道上车的车牌号为:"<<endl;while(p!=NULL){cout<<p->data2->num<<endl;p=p->next;}}elsecout<<"便道上没有车!"<<endl;}测试文件#include "car.h"#include<iostream>using namespace std;void main(){SeqStackCar s1,s2;LinkQueueCar LQ; int m;InitStack(&s1);InitStack(&s2);InitQueue(&LQ);while(1){cout<<"★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★"<<endl;cout<<"1.车辆到达2.离开停车场3.离开便道4.停车场列表5.便道列表6.退出系统"<<endl;cout<<"★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★"<<endl;cin>>m;switch(m){case 1:Arrival(&s1,&LQ);break;case 2:Leave1(&s1,&s2,&LQ);break;case 3:Leave2(&LQ);break;case 4:List1(&s1);break;case 5:List2(&LQ);break;case 6:exit(0);default: break;}}}（两运行结果：个图表联在一起）四、实验总结1．学会了栈和队列的综合使用，更加灵活运用栈和队列。
栈与队列应用举例
设有一个可以停放n辆汽车的狭长停车场,它只有一个大门可以供车辆进出。
车辆按到达停车场时间的先后次序从停车场最里面向门口处停放最先到达的第一辆车停在停车场的最里面)。
如果停车场已放满n辆车,则后来的车辆只能在停车场大门外的便道上等待,一旦停车场内有车开走,则排在便道上的第一辆车就可进入停车场。
停车场内如有某辆车要开走,在它之后进入停车场的车辆都必须先退出停车场为它让路,待其开出停车场后,这些车辆再依原来的次序进入。
每辆车在离开停车场时,根据它在停车场内停留时间的长短交费。
如果停在便道上的车辆未进停车场就要离去,允许其离去时不收停车费,并且仍然保持在便道上等待的车辆的次序。
现在编制一个程序来模拟停车场的管理。
首先确定模拟程序中需要的数据结构及其操作。
由于停车场只有一个大门,因此可用一个栈来模拟;根据便道停车的特点,先排队的车辆先离开便道进入停车场,可以用一个队列来模拟;又因为排在停车场中间的车辆可以提前离开,因此还需要有一个地方(车辆规避所)保存为了让路离开停车场的车辆,很显然这也应该用一个栈来模拟。
所以在程序中设置了两个顺序栈s1和s2分别表示停车场和规避所;设置了一个链队列q表示便道。
它们的数据类型定义在下面的源程序中,为了操作方便,链队列表头结点中的num域中存放便道上的车辆数量。
程序执行时,当输入数据表示有车辆到达时,判断栈s1是否满,若未满就将新数据进栈s1;若栈已满,就将数据入队列q,表示车辆在便道上等待进入停车场。
该操作过程由函数Arrive完成。
当输入数据表示有车辆要离去时,就在栈s1中寻找此车牌号的车辆,如寻找到就让其离开停车场,并根据停车时间计费,同时将队列q 的队头元素进栈s1;如没有找到,就到队列q中去寻找此车牌号的车辆。
如在队列q 中找到就允许其离开队列,并不收费;如找不到就显示出错信息。
当离开停车场的车辆位于栈s1的中间时,必须先将此位置到栈顶之间的所有数据倒到栈s2中去,然后安排车辆出栈s1,最后将栈s2中的数据倒回到栈s1中来。
利用顺序栈或环形队列编写停车场管理程序。
利用顺序栈或环形队列编写停车场管理程序。
停车场管理程序可以利用顺序栈或环形队列进行实现，以下是使用顺序栈的示例：```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")```以上两种实现方式都可以实现停车场管理程序，具体选择顺序栈还是环形队列取决于实际需求。
停车场数据结构算法
2.3 栈与队列的应用2.3.1模拟停车厂管理一．问题描述设停车厂是一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。
汽车在停车场内按车辆到达的先后顺序依次排列，若停车场内已停满汽车，则后来的汽车只能在门外的便道上等候，一旦停车场内有车开走，则排在便道上的第一辆车即可进入；当停车场内某辆车要离开时，由于停车场是狭长的通道，在它之后开入的车辆必须先退出车场为它让路，待该辆车开出大门后，为它让路的车辆再按原次序进入车场。
每辆停放在停车场的车，在离开时按其在停车场停留时间的长短交费。
在这里假设汽车不能从便道上开走。
试设计一个实现停车场管理的程序。
二．基本要求按照从终端输入数据序列进行模拟管理。
1．栈用顺序结构实现，队列用链式结构实现；2．每一组输入数据包括三个数据项：汽车“到达”或“离去”的信息、汽车牌照号码、汽车到达或离去的时刻；3．对每一组输入数据进行操作后的输出信息为：若是车辆到达，则输出车辆在停车场内或便道上的停车位置；若是车辆离去，则输出车辆在停车场内停留的时间和应缴纳的费用（假设在便道上等候的时间不收费）。
三．提示与分析1．根据问题描述可知，使用栈来模拟停车场，使用队列来模拟车场外的便道；还需另设一个辅助栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车；输入数据时必须保证按到达或离去的时间有序。
2．主要数据结构：①为了便于区分每辆汽车并了解每辆车当前所处的位置等信息，需要记录汽车的牌照号码、进入停车场的时刻及汽车的当前状态，汽车的类型定义描述如下：typedef struct{char license_plate; /*汽车牌照号码，定义为一个字符指针类型*/float time; /*汽车进入停车场的时刻*/char state; /*汽车当前状态，字符p表示停放在停车位上，字符q表示停放在便道上*/ }Car；②由于车位是一个狭长的通道，不允许两辆车同时出入停车位，当有车到来时要进入停车位的时候也要顺次停放，当某辆车要离开时，比它后到的车要先暂时离开停车位，而且越后到的车就越先离开停车位，显然这与栈的“后进先出”特点相吻合，因此用栈来描述停车场是合适的。
停车场- 栈和队列
rear J6 J5 J4
5
4 3 2 1 0
J4,J5,J6入队
入队： base[rear]=x; rear=(rear+1)%M; 出队： x=base[front];
front=(front+1)%M;
队满、队空判定条件
队空：front==rear 队满：front==rear
C 构思
设停车场是一个可以停放n辆汽车的东西 方向的狭长通道，且只有一个大门可供汽车进 出。汽车在停车场内按车辆到达的先后顺序， 依次排列，最先到达的第一辆车停放在车场的 最里面），要求编程输出每辆车（车牌号码） 到达后的停车位置。
若车场内已停满n辆车，那么 后来的车只能在门外的便道上等候 ，一旦有车开走，则排在便道上的 第一辆车即可开入。
t->data=p; t->next=NULL;
W->rear->next=t;
W->rear=t;
出 队
//判断通道上是否有车及停车位是否已满 if((W->front!=W->rear)&&Enter->top<MAX) { q=W->front->next; W->front->next=q->next; if(q==W->rear)W->rear=W->front; t=q->data; Enter->top++; Enter->stack[Enter->top]=t;
6 5 4 3 2 1
6 5 4 3 2 1
top top top top
D C B A
6 5 4 3 2 1
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验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 4//存储空间初始分配量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个位置。
\n",p); //不满进停车场栈，并输出位置}}//---*-*-*-*-*-*-*-*-*-*-*-*-*-*-----车辆离开函数--*-*-*-*-*-*-*-*-*-*-*-//void DepartF(SqStack &parking,LinkQueue &road,SqStack &S,car_info t,int &p,int &a){ car_info e;int temp;int Fee;if(t.time==0)//证明在便道上{ e=t;DeQueue(road,e);a--;printf("车辆%d开出便道。
\n",e.car_ID);}else//在停车场{ temp=(*--parking.top).car_ID;//停车场的最后一位置车牌号赋予temp++parking.top;while(temp!=t.car_ID&&!StackEmpty(parking)){ Pop(parking,e);Push(S,e);//从停车场栈出来进入暂存栈temp=(*--parking.top).car_ID;//现有车辆的最后一辆++parking.top;p--;//出去一辆车就p--，表示现有最后一辆车的位置}if(StackEmpty(parking))printf("输入有误！请检查输入数据！！\n");else{ Pop(parking,e);//从停车场出来，但并不进暂存栈，而应计费Fee=GetFee(t,e);printf("该车应缴费用为%d\n",Fee);//计费完毕p--;//从暂存栈进入停车场栈，并且在便道上的第一辆车开始进入停车场栈while(!StackEmpty(S))//只要暂存栈不空{ Pop(S,e);Push(parking,e);//从暂存栈进入停车场栈p++;}//在便道上的第一辆车开始进入停车场站栈，并且应输入进停车场栈时间和在停车场站的位置if(!QueueEmpty(road)){DeQueue(road,e);temp=e.car_ID;printf("车辆%d出便道进停车场，请输入进停车场时间\n",temp);scanf("%d",&e.time);Push(parking,e);p++;}else printf("便道现已没车辆！\n");}}}//--*-*-*-*-*-*-*-主函数*-*-*-*-*-*-//void main(){SqStack parking;SqStack S;LinkQueue road;InitStack(parking);InitStack(S);InitQueue(road);int i=0;int a=0;//显示在便道上的位置int p=0;//显示在停车场上的位置car_info car[100];//用以存放每辆车的数据printf("举例说明本程序用法：\n如果输入A 1 12,表示牌照号为1的车辆到达时间为12！\n");printf("如果输入为D 1 12,表示牌照号为1的车辆离开停车场，离开时间为12！\n");printf("如果下班请输入E 0 0\n");while(1){ i++;printf("请输入车辆进出情况：\n");scanf("%c %d %d",&car[i].AD,&car[i].car_ID,&car[i].time);char c;c=car[i].AD;if(c=='A'){//*-*-*-***--*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*若车辆到达-*-*-*ArriveF(parking,road,car[i],p,a);c=getchar();}else if(c=='D'){//-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-若车辆离开-*-**-*-*-*-**-* DepartF(parking,road,S,car[i],p,a);c=getchar();}else if(c=='E'){ printf("下班时间，回家吃饭！！\n");break;}else{ printf("输入有误！！请重新输入！！\n");c=getchar();}}}四调试分析处于调试需要，本程序设置的停车场容量为4。