顺序栈和链队列

停车场管理

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

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

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

#include<stdio.h>
#include <iostream>
using namespace std;
#include <malloc.h>

typedef struct{
    int car[3];
    int time[3];
    int top;
    int base;
    int stacksize;    
}stack;

typedef struct qnode
{
    int    data;
    qnode *next;
}qnode;

typedef struct
{
    qnode *front;   ///链队列用指针 
    qnode *rear;
}linkqueue;

void initstack(stack *s)//调用的指针 
{
　　s=(stack *)malloc(sizeof(stack));//这一句话可有也可无但是链队列就必须要有了，因为要创造新节点
    s->base=0;
    s->top=0;
    s->stacksize=0;
}

int stackempty(stack s)
{
    return (s.base==s.top);
}

int stackfull(stack s)
{
    return (s.top-s.base==3);
}

void push(stack *s,int name,int ti)
{
    if(s->top-s->base==3)
    return ;
    s->car[s->top]=name;
    s->time[s->top]=ti;
    s->top++;
}

void pop(stack *s,int &name,int &ti)//这里取出来的值name因为是地址进入 
{                                  //所以可以传给主函数 
    if(s->base==s->top)
    return ;
    s->top--;
    name=s->car[s->top];
    ti=s->time[s->top];
    
}
void display(stack s)
{
    int i=s.top-1;
    for(;i>=0;i--)
    {
        cout<<s.car[i];
    }
    cout<<endl;
}

void initqueue(linkqueue *&q)
{
    q=new linkqueue;   //这里很重要，先要给q动态分配空间 
    q->front =q->rear=new qnode;//q的空间都没有，就没有q->front的空间哦 
    q->front->next=NULL;
}

int queuempty(linkqueue q)
{
    return (q.front==q.rear);
}

void pushqueue(linkqueue *q,int name)
{
    qnode *r;     //建立一个新节点指针变量 
    r=new qnode;    //为r动态分配空间 
    r->data=name;
    r->next=NULL;
    q->rear->next=r;
    q->rear=r;
}

void popqueue(linkqueue *q,int &name)
{
    if(q->front==q->rear)
    return ;
    qnode *r;
    r=q->front->next;
    name=r->data;
    q->front->next=r->next;
    if(r==q->rear)
    q->rear=q->front;
    delete(r);
}

void displayq(linkqueue q)
{
    qnode *r;
    if(q.rear!=q.front)
    {
        r=q.front->next;
        do{
            cout<<r->data;
        }while((r=r->next)!=NULL);
    }
    cout<<endl;
}



int main()
{
    int com,t,e1,e2;
    int no,time,i;
    stack s0,s1;
    linkqueue *q;
    initstack(&s0);   //顺序存储结构取地址符，来初始化 
    initstack(&s1);
    initqueue(q);
    do{
        cout<<"输入指令：1到达 2离开 3显示停车场 4显示候车室 0退出\n";
        cin>>com;
        switch(com)
        {
            case 1:cout<<"请输入车号和时间";
                   cin>>no>>time;
                   if(!stackfull(s0))
                   {
                           push(&s0,no,time);
                           cout<<"停车场位置为"<<s0.top-1;
                   }else
                   {
                           pushqueue(q,no);
                   }
                   break;
            case 2:cout<<"请输入车号和时间：";
                   cin>>no>>time;
                   for(i=0;i<=s0.top-1&&s0.car[i]!=no;i++);
                   if(i>=s0.top)
                   {
                           cout<<"未找到该汽车\n";
                   }
                   else
                   {
                          t=s0.top-i-1;
                          for(int j=0;j<t;j++)
                          {
                              pop(&s0,e1,e2);//可以传给主函数的e1，e2 
                              push(&s1,e1,e2);
                        }
                        pop(&s0,e1,e2);
                        cout<<no<<"汽车的费用为"<<(time-e2)*2<<endl;
                        while(!stackempty(s1))
                        {
                            pop(&s1,e1,e2);
                            push(&s0,e1,e2);
                        }
                        if(!queuempty(*q))
                        {
                            popqueue(q,e1);
                            push(&s0,e1,time);
                        }
                   }
                   break;
            case 3:if(!stackempty(s0))
                   {
                           cout<<"停车场中的车辆:";
                           display(s0);
                   }else
                   {
                           cout<<"停车场中无车辆\n";
                   }
                   break;
            case 4:if(!queuempty(*q))
                   {
                           cout<<"候车室中的车辆：";
                           displayq(*q);
                   }else
                   {
                           cout<<"候车室无车辆\n";
                   }
                   break;
            case 0:if(!stackempty(s0))
                   {
                           cout<<"停车场中的车辆:";
                           display(s0);
                   }
                   if(!queuempty(*q))
                   {
                           cout<<"候车室中的车辆：";
                           displayq(*q);
                   }
                   break;
            default:cout<<"输入指令错误\n";
                    break;
        }
    }while(com!=0);
    return 0;
 }