停车场管理（栈和队列的应用）

[问题描述]

设停车场是一个可以停放n辆汽车的狭长通道，只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的车停放在车场的最北端），若车场内已停满n辆车，那么后来的车只能在门外的便道上等候，一旦停车场内有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其他车辆再按原次序进入车场。试为停车场编制按上述要求进行管理的模拟程序。
以栈模拟停车场，以队列模拟车场外的便道。栈用顺序存储结构，队列用链表结构。
每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车车牌号码、到达或离去的时刻。
对每一组输入数据进行操作后的输出信息为：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；当车辆将要离去时，若车在停车场内，模拟输出汽车出入情况并输出汽车在停车场内停留的时间，若车在便道上，直接输出汽车在停车场内停留的时间：0。

[输入]

第一行输入一个整数n：代表停车场最多可以停放n辆汽车。(1<=n<=100)
接下来输入一个整数q：代表有q个信息。(1<=q<=200)
每一个信息，输入三个数据项：汽车到达(“arrive”)或汽车离去（“leave”），汽车的id，以及到达或离去的时间点t。(0<=t<=10000，id只含数字和字母，1<=strlen(id)<=10)
数据保证：q个信息的时间点t升序。

[输出]

对于每一个信息输出一行：
汽车是到达(“arrive”)：如果在便道上输出"Queue",如果在停车场内输出"Stack",并输出所在的位置，栈底的元素是第一个位置，队首的元素是第一个位置(字符串和位置用空格隔开)。
汽车是离开(“leave”)：如果在停车场内，以"汽车id:in/out"模拟输出汽车的移动情况，再输出停留在停车场的时间（忽略让路的时间）；如果在便道上，直接输出汽车在停车场内停留的时间：0。

样例输入 Copy

3
10
arrive A245 0
arrive B478 1
arrive D156 2
arrive C851 5
arrive G156 15
leave C851 20
arrive U11232 30
leave B478 33
leave G156 50
leave U11232 66

样例输出 Copy

Stack 1
Stack 2
Stack 3
Queue 1
Queue 2
0
Queue 2
D156:out B478:out D156:in G156:in 32
G156:out U11232:in 17
U11232:out 16

提示

样例栈和队列的情况 栈底为第一个，队首为第一个
1. 栈：A245 队列：
2. 栈：A245 ，B478 队列：
3. 栈：A245 ，B478，D156 队列：
4. 栈：A245 ，B478，D156 队列：C851
5. 栈：A245 ，B478，D156 队列：C851，G156
6. 栈：A245 ，B478，D156 队列：G156
7. 栈：A245 ，B478，D156 队列：G156,U11232
8. 栈：A245 ，D156，G156 队列：U11232
9. 栈：A245 ，D156，U11232 队列：
10.栈：A245 ，D156 队列：

---

代码

#include<cstring>
#include<iostream>
using namespace std;
int N;
int x=0,y=0;
typedef struct car
{
    int atime;
    int ltime;
    char num[5000];
} car;
//链栈的顺序存储结构
typedef struct sqstack
{
    car *base;
    car *top;
} sqstack;
void Initstack(sqstack &s)     //栈的初始化
{
    s.base=new car[N];//为顺序栈动态分为一个最大容量为N的数组空间
    s.top=s.base;//top初始值为base,空栈
}
bool StackEmpty(sqstack s){  //判断栈是否为空
	if(s.base==s.top)return false;
	else return true;
}
//队列的链式存储结构
typedef struct SqQueue
{
    car *front;//队头指针
    car *rear;//队尾指针
} SqQueue;
void InitQueue(SqQueue &Q)//队列的初始化
{
    Q.front=Q.rear=new car[5000];//生成新结点作为头结点，队头和队尾指针指向此结点
}
void PushStack(sqstack &s,SqQueue &Q,car p)    //入栈
{
    if(s.top-s.base>=N)
    {
        y++;
        *Q.rear=p;
        Q.rear++;
        cout<<"Queue"<<" "<<y<<endl;
    }
    else
    {
        x++;
        *s.top=p;
        s.top++;
        cout<<"Stack"<<" "<<x<<endl;
    }
}
void PushStack0(sqstack &s,car p)      //临时入栈
{
    *s.top=p;
    s.top++;
}
car Pop(sqstack &s)     //出栈
{
    s.top--;
    return *s.top;
}
void Pushd(SqQueue &Q,car p)  //入队
{
    *Q.rear=p;
    Q.rear++;
}
car Pop(SqQueue &Q)       //出队
{
    return *Q.front++;
}
int main()
{
    int num;
    cin>>N;
    cin>>num;
    sqstack s1,s2;
    SqQueue Q;
    Initstack(s1);
    Initstack(s2);
    InitQueue(Q);
    string x1;
    for(int i=1; i<=num; i++)
    {
        cin>>x1;
        if(x1=="arrive")
        {
            car p;
            cin>>p.num>>p.atime;
            PushStack(s1,Q,p);
        }
        else if(x1=="leave")
        {
            car *p;
            p=new car;
            cin>>p->num>>p->ltime;
            car *q;
            q=new car;
            q=s1.base;
            int i=1;
            for(i; i<=x; i++)
            {
                if(strcmp(p->num,q->num)==0)
                    break;
                q++;
            }
            if(i<=x)
            {
                while(1)
                {
                    car d;
                    d=Pop(s1);
                    cout<<d.num<<":out"<<" ";
                    if(strcmp(q->num,s1.top->num)==0)
                        break;
                    PushStack0(s2,d);
                }
                int a=(p->ltime)-(s1.top->atime);
                if(1)
                {
                    while(StackEmpty(s2))
                    {
                        *s1.top=Pop(s2);
                        cout<<s1.top->num<<":in"<<" ";
                        s1.top++;
                    }
                    if(Q.front!=Q.rear)
                    {
                        *s1.top=Pop(Q);
                        s1.top->atime=p->ltime;
                        cout<<s1.top->num<<":in"<<" ";
                        s1.top++;
                        y--;
                    }
                    else
                        x--;
                }
                cout<<a<<endl;
            }
            else
            {
                cout<<"0"<<endl;
                y--;
                Q.front++;
            }
        }
    }
}