栈与队列--停车场

问题描述：

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

基本要求：

以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列管理，每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时间，对每一组输入数据进行操作后的输出数据为： 若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用（在便递上停留的时间不收费），栈以顺序结构实现，队列以链表结构实现。

实现提示：

需另设一栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车，也用顺序存储结构实现。输入数据按到达或离去的时刻有序。栈中每个元素表示一辆汽车，包含有两个数据项：汽车牌照号码和进入停车场的时间。

选作内容：

（1）两个栈共享空间，思考应开辟数组的空间是多少 ?

（2）汽车可有不同种类，则它们的占地面积不同，收费标准也不同，如 1 辆客车和 1.5 辆小汽车的占地面积相同，1辆十轮卡车占地面积相当于3辆小汽车的占地面积 。

（3）停放在便道上的汽车也收费，收费标准比停放在停车场的车低，请思考如何修改结构以满足这神要求。

Input

输入第一行，包括两个数据，第一个整数为停车场最多可停放车辆数，第二个浮点数表示单位时间的停车费用。接下来有多行数据，每行有三个整数，第一个为0或1，0表示进入车场，1表示离开车场；第二个整数为车号；第三个整数为进入或离开的时间。当一行中三个数均为0时表示输入结束，所有数据之间由空格分隔。

Output
输出为三部分，第一部分为按离开停车场顺序打印出的各车费用，每车一行，包括车号和费用(保留小数点后两位)。第二部分占一行为当前停车场中的所有车辆，从北到南顺序输出各车车号。第三部分占一行为当前便道上的所有车辆，从前向后顺序输出各车车号。各车号之间由一个空格分隔。

Sample Input

2  1.5

0  1  5

0  2  10

1  1  15

0  3  20

0  4  25

0  5  30

0  6  35

1  2  40

0  7  45

1  6  50

0  0  0

Sample Output

1  15.00

2  45.00

3  4

7  5

代码如下：

#include<stdio.h>
#include<stdlib.h>




int max;
float price;
//把停车场限额和费用作为全局变量


typedef struct
{
int arrivetime;
int leavetime;
int carnumber;
}CAR;
//汽车信息结构体定义




typedef struct 
{
CAR *base;
CAR *top;
    int stacksize;
}stack;
//栈的定义(顺序结构)






typedef struct qnode
{
int arrivetime;
int leavetime;
int carnumber;
qnode *next;
}qnode;
//队列结点的定义（链表结构）




typedef struct
{
qnode *front;
qnode *rear;
}queue;
//队列的定义




bool Initstack(stack &stk)
{
    stk.base=(CAR *)malloc(max*sizeof(CAR));
if(!stk.base)
{
printf("初始化栈失败！");
return false;
}
stk.top=stk.base;
stk.stacksize=max;
return true;
}
//初始化栈的函数










bool Initqueue(queue &que)
{
    que.front=(qnode *)malloc(sizeof(qnode));
if(!que.front)
{
printf("初始化队列失败!");
return false;
}
que.rear=que.front;
que.front->next=NULL;
return true;
}
//初始化队列的函数




/*
int judge(stack stk)
{
if(stk.top-stk.base==stk.stacksize)
{
return 1;
}
return 0;
}
//判断栈是否为空
*/




void incar(stack &stk,queue &que,int carnumber,int arrivetime)
{
     if(stk.top-stk.base==stk.stacksize)
 {
         qnode *p;
 p=(qnode *)malloc(sizeof(qnode));
 p->next=NULL;
         //定义初始化p结点




 //p->arrivetime=arrivetime;
 p->carnumber=carnumber;
         //将新入库的汽车用p结点来表示




 que.rear->next=p;
 que.rear=p;
 //将p结点存入到队列头节点后面
 }
 //栈已满，将数据存入队列中，在头节点后面
 else{
 stk.top->arrivetime=arrivetime;
//  printf("\n%d\n",stk.top->arrivetime);
 stk.top->carnumber=carnumber;
 ++stk.top;
 //将数据存入栈中
 }
 //栈未满，将数据存入栈中
}
//汽车入的函数










bool outcar(stack &stk,queue &que,int carnumber,int leavetime)
{
int flag=0;
qnode *p,*q,*r;//要用到的队列指针

//栈的寻找
stack stk1;
Initstack(stk1);
while(stk.base!=stk.top)
{
--stk.top;
if(stk.top->carnumber==carnumber)//在栈中找到了该汽车
{ 
printf("%d %.2f\n",carnumber,(leavetime-stk.top->arrivetime)*price);//输出数据
flag=1;
break;
}
else//没有找到，将stk的数据存到stk1中，继续循环往下走
{

stk1.top->arrivetime=stk.top->arrivetime;
stk1.top->carnumber=stk.top->carnumber;
++stk1.top;
    //将stk的数据存到stk1中
}
}
    while(stk1.base!=stk1.top)//stk1中有数据
{

--stk1.top;
stk.top->arrivetime=stk1.top->arrivetime;
stk.top->carnumber=stk1.top->carnumber;
++stk.top;
}
//将stk1的数据存到stk中




if((que.front->next!=NULL)&&(stk.top-stk.base!=stk.stacksize))//当队列中有车并且栈未满
{
stk.top->arrivetime=leavetime;
stk.top->carnumber=que.front->next->carnumber;
++stk.top;
//向栈中加汽车


        p=que.front->next;
        que.front->next=p->next;
//将队列中的第一辆车拿走
}
    //如果队列中有车并且栈未满，在从队列中取出数据拿到栈中




if(flag==1)
{
return true;
}
    //如果在栈中找到了该车辆，则函数执行结束




//队列

    p=que.front;
q=p;
while(p->next!=NULL)
{
p=p->next;
if(p->carnumber==carnumber)//在队列中找到要出的车辆
{
flag=1;//在队列中找到了该车辆




r=p->next;//出去的车的下一个，将会变成第一个车
q->next=NULL;//出去的车上一个，此操作将与出去车断绝关系




q=r;//q作为循环指针




while(q->next==NULL)
{
break;
}
//用q指针来找出原来车队的最后一个




q->next=que.front->next;//出去车的前面的车排到后面


que.front->next=r;//出去车的下一个作为第一个


return true;
//输出车号和费用,停止寻找
}
else//没有找到继续往下找
{
q=p;
}
}
//在队列中的寻找结束
if(flag==1)
{
return true;
}
printf("没有该车的信息！！\n");
return false;
}
//汽车出的函数






void output(stack stk,queue que)
{
    printf("\n");
while(stk.base!=stk.top)
{
printf("%d ",stk.base->carnumber);
stk.base++;
}
printf("\n");
    //栈的输出






    
qnode *p;


p=que.front;
while(p->next!=NULL)
{
printf("%d ",p->next->carnumber);
p=p->next;
}
printf("\n");
//队列的输出
}






int main()
{


scanf("%d%f",&max,&price);
//输入停车场的限额和停车费用


    


stack stk;
queue que;
    Initstack(stk);
Initqueue(que);
    //初始化栈和队列
    
    
    int condition,carnumber,time;
while(1)
{
scanf("%d%d%d",&condition,&carnumber,&time);
if(condition==0  &&  carnumber==0   &&   time==0)
{
break;
}
if(condition==0)
{
incar(stk,que,carnumber,time);
}
    if(condition==1)
{
outcar(stk,que,carnumber,time);
}
}
//输入汽车的进出信息，并处理汽车出还是入,还有输出出去汽车的信息（由outcar来执行）
    


output(stk,que);
//按顺序输出停车场和通道里所有车辆的号码




return 0;
}