停车场的模拟管理（数据结构 C++）

[问题描述]：
          设有一个可以停放n辆汽车的狭长停车场，它只有一个大门可以供车辆进出。车辆到达停车场时间的早晚依次从停车场最里面向大门口处停放（最先到达的第一辆车放在停车场最里面）。如果停车场已放满n辆车，则后来的车辆只能停在停车场大门外的便道上等待，一旦停车场里有车开走，则排在便道上的第一辆车就进入停车场。若停车场内有某辆车要开走，在它之后进入停车场的车都必须先退出停车场，为它让路，待其开出停车场后，这些车再依原来的次序进场。每辆车离开停车场

  时，都应根据其在停车场的逗留时间交费。如果停留在便道上的车未进停车场就要离去，允许其离去，不收停车费，并且仍然保持在便道上等待的车辆顺序。编制一程序模拟停车场的管理。

【实现要求】

 1、要求程序输出每辆车到达后的停车位置（停车场）或便道上；

 2、某辆车离开停车场时应交纳的费用和停留时间；

程序设计

#include "stdio.h"
#include "stdlib.h"
#define A 5                /* 停车单价 */
#define TRUE 1
#define FALSE 0
#define NULL 0
#define Stack_Size 2  /* 车库容量 */
typedef struct
{
    int elem1[Stack_Size];
    int elem2[Stack_Size];
    int elem3[Stack_Size];
    int elem4[Stack_Size];
    int top;
}SeqStack;                /* 定义栈的结构体 */
typedef struct Node
{
    int date;
    int num;
    int hour;
    int minute;
    struct Node *next;
}LinkQueueNode;            /* 定义链队列结点的结构体 */
typedef struct
{
    LinkQueueNode *front;
    LinkQueueNode *rear;
}LinkQueue;                /* 定义链队列的结构体*/
InitQueue(LinkQueue *Q) /* 初始化链队列函数 */
{
    Q->front=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
    if(Q->front!=NULL)
    {
        Q->rear=Q->front;
        Q->front->next=NULL;
        return(TRUE);
    }
    else return(FALSE);
}
EnterQueue(LinkQueue *Q,int x,int y,int z,int w) /* 入链队列函数 */
{
    LinkQueueNode *NewNode;
    NewNode=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
    if(NewNode!=NULL)
    {
        NewNode->num=x;
        NewNode->date=y;
        NewNode->hour=z;
        NewNode->minute=w;
        NewNode->next=NULL;
        Q->rear->next=NewNode;
        Q->rear=NewNode;
        return(TRUE);
    }
    else return(FALSE);
}
DeleteQueue(LinkQueue *Q,int *x,int *y,int *z,int *w) /* 删除链队列结点函数 */
{
    LinkQueueNode *p;
    if(Q->front==Q->rear)
    {
        return(FALSE);
    }
    p=Q->front->next;
    Q->front->next=p->next;
    if(Q->rear==p)
    {
        Q->rear=Q->front;
    }
    *x=p->num;
    *y=p->date;
    *z=p->hour;
    *w=p->minute;
    free(p);
    return(TRUE);
}
void InitStack(SeqStack *S)            /* 初始化栈 */
{
    S->top=-1;
}
int Push(SeqStack *S,int x,int y,int z,int w)    /* 栈插入函数 */
{
 
    S->elem1[S->top]=x;
    S->elem2[S->top]=y;
    S->elem3[S->top]=z;
    S->elem4[S->top]=w;
    S->top++;
    return(TRUE);
}
int Pop(SeqStack *S,int *x,int *y,int *z,int *w)    /* 栈删除函数 */
{
    if(S->top==-1)
    {
        return(FALSE);
    }
    else {
          S->top--;
          *x=S->elem1[S->top];
          *y=S->elem2[S->top];
       *z=S->elem3[S->top];
       *w=S->elem4[S->top];
       
        return(TRUE);
    }
}
int IsFull(SeqStack *S) /* 判断栈满函数 */
{
    return(S->top==Stack_Size-1?TRUE:FALSE);
}
int IsEmpty(SeqStack *S) /* 判断栈满函数 */
{
    return(S->top==-1?TRUE:FALSE);
}
int choose() /* 选择函数 */
{
    int m;
    printf(" 请选择:1. 停车; 2. 停车场出车; 3. 便道出车;4.退出  ");
    scanf("%d",&m);
    if(m==1||m==2||m==3)
    {
        return(m);
    }
    if(m==4)
    {
        exit(0); /* 整个程序由此结束 */
    }
    else
    {
        printf("选择错误!");
        exit(1);
    }
}
void main()
{
    int m,num,pp=1,k=0,p=0,x,y,z,w,t ,date,hour,minute;
    LinkQueue *Q=(LinkQueue*)malloc(sizeof(LinkQueue));
    SeqStack *S=(SeqStack*)malloc(sizeof(SeqStack)),*R=(SeqStack*)malloc(sizeof(SeqStack));
    InitQueue(Q);
    InitStack(R);
    InitStack(S);  
    while(pp!=0)                        /* 控制程序一直循环 */
    {
        m=choose();                        /* 整个程序由此进 */
        printf("请输入汽车号码: ");
        scanf("%d",&num);
        printf("请输入时间:例:20,7:35表示某月20日7:35停车或出车 ");
        scanf("%d,%d:%d",&date,&hour,&minute);
        if(m==1)
        {
            printf("No.%d 号汽车停在 ",num);
            if(IsFull(S))                        /* 先判断车库是否满了 */
            {
                EnterQueue(Q,num,date,hour,minute);            /* 如果满了,则放入便道里(链队列) */
                k++;                            /* 便道里的位置计数器 */
                printf("便道中的第 %d 号位置. ",k);
            }
            else
            {
                Push(S,num,date,hour,minute);                /* 如果不满,则放入车库里(顺序栈) */
                p++;                            /* 车库里的位置计数器 */
                printf("停车场的第 %d 号位置! ",p);
            }
        }
        if(m==2)
        {
            if(IsEmpty(S))                        /* 判断车库还有车吗,其作用为防止非法输入 */
            {
                printf("车库为空,No.%d 不在!",num);
                exit(2);
            }
            while(num!=S->elem1[S->top]) /* 寻找所要出的车 */
            {
                Pop(S,&x,&y,&z,&w);            /* 车库最外辆车出库 */
                while(p>0)
                {
                    p--;                /* 出车则减一个数 */
                }
                Push(R,x,y,z,w);            /* 将刚出的车入临时车库(顺序栈) */
            }
            Pop(S,&x,&y,&z,&w);                /* 找到车后将其弹出 */
            p--;                        /* 出车则减一个数 */
            t=(date-y)*1440+(hour-z)*60+minute-w;                    /* 计算其停车时间 */
            printf("No.%d 的车在车库停了 %d 分钟.$:%d ",num,t,t*A);
            while(!IsEmpty(R))
            {
                Pop(R,&x,&y,&z,&w);
                Push(S,x,y,z,w);
                p++;
            }                            /* 将临时车库的车全部转到车库 */
            if(Q->front!=Q->rear)        /* 判断便道是否有车 */
            { DeleteQueue(Q,&x,&y,&z,&w);        /* 如果有则出便道 */
                Push(S,x,y,z,w);            /* 进车库 */
                p++;                    /* 车库计数器加1 */
                k--;                    /* 便道计数器减1 */
            }
        }
        if(m==3)
        {
          
             DeleteQueue(Q,&x,&y,&z,&w);
              k--;
              t=(date-y)*1440+(hour-z)*60+minute-w;
              printf("No.%d 的车在便道停了 %d 分钟.",num,t);
            
        }
    }   
}