数据结构（C语言）课设2——停车场管理（栈和队列）

数据结构（C语言）课设2——停车场管理系统（栈和队列）

题目描述
设停车场是一个可以停放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。

头文件

• 所需的头文件

#include 

using namespace std;

#define MAX 100

建立车辆信息结构体和存储结构

• 先创建储存车辆信息的结构体和栈、队列的存储结构：停车场用顺序栈的存储结构，便道用链队列的存储结构；车辆信息：到达离开、车牌号、到达时间

typedef struct//车辆信息
{
    string arriveLeave;
    string carNumber;
    int time;
}Car;
typedef struct//顺序栈
{
    Car *base;
    Car *top;
    int maxSize;
}SqStack;
typedef struct QNode//队列结点
{
    Car data;
    struct QNode *next;
}QNode, *Qcar;
typedef struct//链队列
{
    Qcar front;
    Qcar rear;
}LinkQueue;

栈和队列的初始化以及入栈、出栈、入队、出队

• 初始化顺序栈

void InitStack(SqStack &S, int n)//初始化顺序栈
{
    S.base = new Car[n];
    if(!S.base)
    {
        cout<<"error"<<endl;
    }
    S.top = S.base;
    S.maxSize = n;
}

• 初始化链队列

void InitQueue(LinkQueue &Q)//链队列初始化
{
    Q.front = Q.rear = new QNode;
    Q.front->next = NULL;
}

• 入栈操作

void Push(SqStack &S, Car e)//入栈
{
    *S.top++ = e;
}

• 出栈操作

void Pop(SqStack &S, Car &e)//出栈
{
    e = *--S.top;
}

• 入队操作

void EnQueue(LinkQueue &Q, Car e)//入队
{
    Qcar p;
    p = new QNode;
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
}

• 出队操作

void DeQueue(LinkQueue &Q, Car &e)//出队
{
    Qcar p;
    if(Q.front == Q.rear)
    {
        cout<<"error"<<endl;
    }
    p = Q.front->next;
    e = p->data;
    Q.front->next = p->next;
    if(Q.rear == p)
    {
        Q.rear = Q.front;
    }
    delete p;
}

进停车场函数

• 首先是入栈：根据主函数调用进停车场函数，传进来的arriveLeaveInfo信息为arrive，传进函数的n的值为停车场最多能停放n辆车；则接下来在函数内输入进入车辆的其余信息，若栈顶指针减栈底指针小于n,则说明停车场还有空位，将输入的车辆信息入栈并且输出题目要求的信息；否则入队（进入便道）调用入队函数，下一条继续讲解

void inParking(SqStack &S, LinkQueue &Q, string arriveLeaveInfo, int n)
{
    Car carInfo;
    carInfo.arriveLeave = arriveLeaveInfo;
    cin>>carInfo.carNumber;
    cin>>carInfo.time;
    if((S.top-S.base) < n)
    {
        Push(S, carInfo);
        cout<<"Stack"<<" "<<(S.top-S.base)<<endl;
    }
    else if(S.top-S.base == S.maxSize)
    {
        inParking_D(Q,carInfo);
    }
}

• 现在来讲入便道：在上个入栈函数内若栈满（停车场满）则调用入便道函数，并且将输入的车辆信息传入此入便道函数；先调用入队函数将信息入队，接着while循环中利用指针q遍历队列，使t计数，最后输出题目要求的信息

void inParking_D(LinkQueue &Q, Car carInfo)
{
    int t = 0;
    EnQueue(Q, carInfo);
    Qcar q = Q.front;
    while(q->next != Q.rear->next)
    {
        t++; //这个循环只是为了知道此时入队的车是队列的第几辆
        q = q->next;
    }
    cout<<"Queue"<<" "<<t<<endl;
}

出停车场函数（我认为这个函数的设计是本题的重点！）

• 函数的算法思想我在代码里做了详细的注释（有兴趣的小伙伴可以认真康康哈）最主要的看看两个栈互相倒，两个队列互相倒，以及若判断到出栈的车辆在停车场，之后它出栈后，则会多出一个空位，那么同时需判断便道上是否有车，若有车，则需要将便道上的车进入停车场；还有就是车辆进停车场的时间，如果别的车辆需要出栈的同时，此车必须出栈再入栈，那么车的入栈时间就会更新，而不是初始输入的进入时间

void outParking(SqStack &S, LinkQueue &Q, string arriveLeaveInfo, int n)
{
    int outTime = 0;
    Car carInfo, outCarInfo;
    SqStack s;
    InitStack(s, n);
    LinkQueue q;
    InitQueue(q);
    carInfo.arriveLeave = arriveLeaveInfo;
    cin>>carInfo.carNumber;
    cin>>carInfo.time;
    bool flag = false;   //初始化flag为false
    while(Q.front != Q.rear)     //若队列不为空时则while循环遍历队列
    {
        DeQueue(Q, outCarInfo);    //将队列中一个个出队
        if(outCarInfo.carNumber == carInfo.carNumber)//如果出队的车牌号等于要要走的车的车牌号
        {
            cout << "0" <<endl;//若相等则代表要走的车在便道上，按照题意输出0
            flag = true;//找到则标记flag为true
        }
        else
        {
            EnQueue(q, outCarInfo);//若没有找到则将出队的车用另一个队列记录下来
        }
    }
    while(q.front != q.rear)
    {
        DeQueue(q, outCarInfo);
        EnQueue(Q, outCarInfo);//这一步将另一个队列记录的车放回原队列
    }
    if(!flag)//如果flag为初值false，则代表要走的车辆在便道上没有找到，说明车辆一定在停车场
    {
        int j, i;
        for(i = 0; i < n; i++)//n为指定停车场最多能停放的车辆
        {
            Pop(S, outCarInfo);//循环里一个个出栈寻找
            cout<<outCarInfo.carNumber<<":"<<"out"<<" ";
            if(outCarInfo.carNumber == carInfo.carNumber)
            {//若相等则代表在停车场找到指定车辆，将指定车辆的出栈时间减进栈时间记录下来
                outTime = carInfo.time - outCarInfo.time;
                break;//找到后结束循环
            }
            Push(s, outCarInfo);//将出栈的车辆入另一个栈s记录下来
        }
        for(j = 0; j < i; j++)//for循环将在另一个栈s里出栈的放进原来栈S
        {
            Pop(s, outCarInfo);
            Push(S, outCarInfo);
            cout<<outCarInfo.carNumber<<":"<<"in"<<" ";//进栈同时输出进栈信息
        }
        if(Q.front != Q.rear)//根据题意，当停车场出一辆车则多出一个车位，若便道上有车则需将便道上的车往停车场进一辆
        {//if判断队列是否为空
            DeQueue(Q, outCarInfo);//不为空则出队
            outCarInfo.time = carInfo.time;//同时将出栈内车停车场时间赋给便道车进栈时间
            Push(S, outCarInfo);//进栈
            cout<<outCarInfo.carNumber<<":"<<"in"<<" ";
        }
        cout<<outTime<<endl;//停车场停留时间
    }
}

主函数设计

• main函数的设计

int main()
{
    int n, m;
    string str;
    SqStack S;
    LinkQueue Q;
    InitQueue(Q);
    cin>>n;
    InitStack(S, n);
    cin>>m;
    while(m--)
    {
        cin>>str;
        if(str == "arrive")//根据题意若输入arrive就进停车场
        {
            inParking(S, Q, str, n);
        }
        else if(str == "leave")//相反
        {
            outParking(S, Q, str, n);
        }
    }
    return 0;
}

题目样例输入输出

• 样例输入

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

• 样例输出

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

运行结果图

• 运行结果图
  

此博文只用于记录博主学习过程