模拟停车场管理系统（c++,使用栈和队列）

目录

一、问题描述

二、算法结构分析与设计

三、算法主模块的流程及各子模块的主要功能

四、算法详细设计

五、源代码

---

一、问题描述

1. 功能要求

        设停车场只有一个可以停放几辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达的先后顺序依次排列，若车场内已经停满几辆汽车，则后来的汽车只能在门外的便道上等候，一旦有汽车开走，则排在便道上的第一辆汽车即可进入，当停车场某辆车要离开时，由于停车场是狭长通道，在他之后开入的车辆必须先退出车场为他让路，待该辆汽车开出大门之后，为他让路的车辆按照原次序进入车场。在这里假设汽车不能从便道上开走。

     2.输入输出要求

每一组输入数据要求包括三个数据项：汽车“到达”或“离去”的信息、汽车拍照号码、汽车到达或者离去的时刻。

二、算法结构分析与设计

1. 时间

typedef struct Time

{

    int mon=0;

    int date=0;

    int hour=0;

    int min=0;

    int sec=0;

    

}Time;

2.汽车

typedef struct Car

{

    string ChePai="";

    Time in;

    Time out;

}Car;

3.顺序栈

typedef struct SeqStack

{

    Car CheWei[MAXSIZE];

    int top=-1;

    

}SeqStack;

4.链式队列

typedef struct QNode

{

    Car data;

    QNode *next=NULL;

    

}QNode;

typedef struct LQueue

{

    QNode *front,*rear;

    

}LQueue;

三、算法主模块的流程及各子模块的主要功能

子模块的主要功能：

1）压栈和出栈：SeqStack* InStack(SeqStack* pl,Car a)

SeqStack* OutStack(SeqStack* pl,Car a)

2）入队和出队：LQueue* InQueue(Car a,LQueue* p)

Car OutQueue(LQueue* p)

3）初始化队：LQueue* InitLQueue()

4）获取系统时间，计算时间差：void differ(Time in,Time out)

Time GetTime()

5）算钱：int MoneyCalculate(int MoneyPH,Time in,Time out)

主程序流程：

四、算法详细设计

1.写出各个模块的伪码算法

得到系统时间：

{获取系统时间

赋值返回

}

寻找车辆用于查询：

{遍历栈，若查询到车牌一致，返回

遍历队列，若查询到车牌一致，返回

}

入栈：

{top指针上移

获取系统时间，赋给car进入的时间

装填数据

}

出栈：

{如果内部车辆出栈,外部车辆压入辅助栈，内部车辆出栈，外部车辆压回；

如果最外边的车辆出栈，则直接出栈。

获取系统时间，计算时间差，计算应缴纳的金额。

}

计算缴纳的费用：

{计算停泊了几个小时，不超过半个小时的部分忽略不计

自定义每小时停泊的价格，返回总金额

}

初始化队：

{申请头节点空间和第一个数据节点的空间

头节点的头尾指针均指向第一个数据节点

第一个数据节点的后继置空

返回头节点

}

入队：

{获取系统时间，赋给进入的车辆

如果此时便道内没有车辆，第一个数据节点装填

如果此时便道内已经有了车辆，申请新的节点空间，装填数据，尾指针后移

返回头节点

}

出队：

{如果便道内有多个车辆，用一个node类型指针指向待入车辆，用一个car变量承接数据，出队之后释放指针指向的空间，返回承接的数据

如果只有一个车辆，用一个car类型指针指向数据，承接数据后释放指针，返回数据

}

五、源代码

#include
#include
using namespace std;
#define MAXSIZE 5
typedef int DataType;

//定义时间
typedef struct Time
{
    int mon=0;
    int date=0;
    int hour=0;
    int min=0;
    int sec=0;
    
}Time;


typedef struct Car
{
    string ChePai="";
    Time in;
    Time out;
    
}Car;


//定义顺序栈
typedef struct SeqStack
{
    Car CheWei[MAXSIZE];
    int top=-1;
    
}SeqStack;


//定义链式队列
typedef struct QNode
{
    Car data;
    struct QNode *next=NULL;
    
}QNode;

typedef struct LQueue
{
    QNode *front=NULL,*rear=NULL;
    
}LQueue;


void TimePrint(Time a)
{
    cout<<"时间为："<tm_mon+1;
    a.date=p->tm_mday;
    a.min=p->tm_min;
    a.hour=p->tm_hour;
    a.sec=p->tm_sec;
    return a;
}

Car Search(SeqStack* pl,LQueue* bd,Car op)
{
    int j=1;
    //先在栈内找
    for(int i=0;i<=pl->top;i++)
    {
        if(pl->CheWei[i].ChePai==op.ChePai)
        {
            cout<<"在第"<CheWei[i];
        }
    }
    
    //然后在队列里找
    QNode* p=bd->front;
    while(op.ChePai!=p->data.ChePai&&p->next!=NULL)
    {
        p=p->next;
        j++;
    }
    cout<<"车在便道的第"<data;
}

SeqStack* InStack(SeqStack* pl,Car a)
{
    pl->top++;
    
    a.in=GetTime();
    pl->CheWei[pl->top]=a;
    TimePrint(a.in);
    return pl;
}

//汽车离去，出栈
SeqStack* OutStack(SeqStack* pl,Car a)
{
    SeqStack* fz=new SeqStack();//注意，需要将指针初始化。
    
    while(pl->CheWei[pl->top].ChePai!=a.ChePai)
    {
        fz->top++;
        fz->CheWei[fz->top]=pl->CheWei[pl->top];
        pl->top--;
        
    }
    
    while(fz->top!=-1)
    {
        
        pl->CheWei[pl->top]=fz->CheWei[fz->top];
        pl->top++;
        fz->top--;
        
    }
    pl->top--;
    a.out=GetTime();
    TimePrint(a.out);
    int MoneyCalculate(int MoneyPH,Time in,Time out);
    int money=MoneyCalculate(5,a.in,a.out);//所需要的金额一并输出
    void differ(Time in,Time out);
    differ(a.in,a.out);
    cout<<"应缴纳："<=30)
        out.hour++;//超过半个小时部分按一个小时计算
    money=MoneyPH*(out.hour-in.hour);
    return money;
    
}

//计算时间差
void differ(Time in,Time out)
{
    Time d;
    if(out.minfront=q;
    p->rear=q;
    q->next=NULL;
    return p;
    
    
}
LQueue* InQueue(Car a,LQueue* p)
{//传入需要入队的车辆信息和便道队的地址
    a.in=GetTime();
    if(p->front->data.ChePai=="")
    {
        p->front->data=a;
        return p;
    }
    else
    {
        QNode* q=new QNode();
        q->data=a;
        p->rear->next=q;
        p->rear=q;
        return p;
    }
}

//出队，得到车辆
Car OutQueue(LQueue* p)
{
    Car RIn;
    Car* op1;
    if(p->front!=p->rear)
    {
        QNode* q=p->front;
        p->front=p->front->next;
        RIn=q->data;
        free(q);
        return RIn;
    }
    else
    {
        RIn=p->front->data;
        op1=&(p->front->data);
        free(op1);
        return RIn;
        
    }
    
}

void CarInfPrint(Car a)
{
    cout<<"车牌号为："<>a;
        
        //查询车辆信息
        if(a=="1")
        {
            cout<<"请输入车牌号："<>op.ChePai;
            op=Search(pl, bd, op);
            differ(op.in,GetTime());
            CarInfPrint(op);//车牌号打印正常。
            continue;
        }
        
        //录入车辆信息
        if (a=="2")
        {
            string b;
            
            cout<<"离去请按1，到达请按2"<>b;
            
            //离去
            if(b=="1")
            {
                
                cout<<"请输入车牌号："<>op.ChePai;
                op=Search(pl, bd, op);
                OutStack(pl, op);
                if(bd->front->data.ChePai!="")
                {
                    op1=OutQueue(bd);
                    InStack(pl,op1);
                }
                continue;
                
            }
            //到达
            if(b=="2")
            {
                cout<<"请输入车牌号："<>cp;
                op.ChePai=cp;
                if(pl->top==MAXSIZE-1)
                    InQueue(op,bd);
                if(pl->top