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

最新推荐文章于 2024-02-19 16:52:03 发布

咕咕精

最新推荐文章于 2024-02-19 16:52:03 发布

阅读量1.1k

点赞数 5

本文链接：https://blog.csdn.net/a201808064823/article/details/104274384

版权

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

1.问题描述

[题目描述]

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

[样例输入]

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

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 队列：

2.需求分析

//定义一个汽车结构体

struct CAR{

int time;//时间

string name;//车牌号

CAR(){}

CAR(int t,string n):time(t),name(n){}

};

//定义一个栈结构体

struct Stackk

{

}s;

//定义一个队列结构体

struct Queuee

{

}q;

3.算法设计

1. init()//创建栈

2. empty()//判断栈空

3. isfull()//判断栈满

4. size()//求栈的长度

5. push(CAR x)//入栈

6. pop()//出栈

7. top()//返回栈顶元素

8. init()//创建队列

9. empty()//判断队列是否为空

10. isfull()//判断队列是否为满

11. size()//求队列长度

12. push(CAR x)//入队列

13. pop()//出队列

14. find(string x)//找车牌号

15. erase(string x)//抹去、删除

4.调试分析

使用结构体存储栈和队列，简化了创建和入栈、出栈的代码，较为简便。本题使用了两个栈和一个队列，一个栈用作停车场，另一个栈用作退车时的临时便道，队列用来当作便道。这样，栈里的车辆可以做到先进后出，队列里的车辆可以做到先进先出。

5.实验结果

#include<stdio.h>
#include<math.h>
#include<string.h>
#include<iostream>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1  
#define OVERFLOW -2
typedef int Status;
typedef int Boolean;
typedef int ElemType;
const int STACK_SIZE = 1000;
const int QueueSize = 1000;
int MAX_STACK;
const int Max_num=1000;

//定义一个汽车结构体 
struct CAR{
    int time;//时间 
    string name;//车牌号 
    CAR(){}
    CAR(int t,string n):time(t),name(n){}
};

//定义一个栈结构体 
struct Stackk
{
    CAR s[Max_num];
    int index;
    void init()//创建栈 
	{ 
	    index=0;
	}
    bool empty()//判断栈空 
	{
        if(index==0)
            return 1;
        else
            return 0;
	}
    bool isfull()//判断栈满 
	{
	    if(index>=Max_num)
	        return 1;
        else
            return 0;
	}
    int size()//求栈的长度 
	{ 
	    return index;
	}
    void push(CAR x)//入栈 
	{ 
	    s[index++]=x; 
	}
    void pop()//出栈 
	{ 
	    index--;
	}
    CAR top()//返回栈顶元素 
	{ 
	    return s[index-1];
	}
}s;

//定义一个队列结构体 
struct Queuee
{
    CAR q[Max_num];
    int l,index;
    void init()//创建队列 
	{ 
	    l=0,index=0;
    }
    bool empty()//判断队列是否为空 
	{ 
	    if(l==index)
	        return 1;
        else
            return 0;
	}
    bool isfull()//判断队列是否为满 
	{
	    if(index>=Max_num)
	        return 1;
        else
            return 0;
	}
    int size()//求队列长度 
	{ 
	    return index-l;
	}
    void push(CAR x)//入队列 
	{ 
	    q[index++]=x; 
	}
    void pop()//出队列 
	{
	    l++;
	}
    CAR front()
	{ 
	    return q[l];
	}
    int find(string x)//找车牌号 
	{
        for(int i=l;i<=index;++i)
        if(q[i].name==x) return i;
        return -1;
    }
    void erase(string x)//抹去、删除 
	{
        for(int i=find(x);i<=index;++i)
        q[i]=q[i+1];
        --index;
    }
}q;

bool find(string x)
{
    Stackk tmp;//临时栈
    tmp.init();
    bool f=false;
    while(!s.empty())
	{
        if(s.top().name==x) f=true;
        tmp.push(s.top());
		s.pop();
    }
    while(!tmp.empty())
	{
        s.push(tmp.top());
		tmp.pop();
    }
    return f;
}

int main()
{
	int n,Q;
    cin>>n>>Q;
    s.init();
	q.init();
    while(Q--)
	{
        int t;
        string judge,car;
		cin>>judge>>car;
		cin>>t;
        if(judge=="arrive"){
            if((int)s.size()<n){
                s.push(CAR(t,car));
                cout<<"Stack "<<s.size()<<endl;
            }else{
                q.push(CAR(-1,car));
                cout<<"Queue "<<q.size()<<endl;
            }
        }
		else if(judge=="leave")
		{
            int tt=t;
            if(find(car))
			{
                Stackk tmp;//临时栈
				tmp.init();
                while(!s.empty()){//当栈不为空 
                    CAR now=s.top();//取栈顶元素now 
					s.pop();//出栈 
                    cout<<now.name<<':'<<"out ";
                    if(now.name==car)
					{
					    t-=now.time;
						break;
					}
                    tmp.push(now);
                }
                while(!tmp.empty())//当临时栈不为空 
				{
                    CAR now=tmp.top();
					tmp.pop();
                    cout<<now.name<<':'<<"in ";
                    s.push(now);//临时栈的栈顶元素进入栈 
                }
                if(((int)s.size()<n)&&(!q.empty()))
				{
                    CAR now=q.front();//取对头元素 
					q.pop();//出队 
                    if(now.time==-1) now.time=tt;
                    s.push(now);
                    cout<<now.name<<':'<<"in ";
                }
                printf("%d\n",t);
            }
			else
			{
                q.erase(car);
				puts("0");
            }
        }
    }
    return 0;
}

咕咕精

关注

5
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
课设-停车场管理（栈和队列的应用）

停车场管理（栈和队列的应用）1.问题描述[题目描述]设停车场是一个可以停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满n辆车，那么后来的车只能在门外的便道上等候，一旦停车场内有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后进入的车...
复制链接

扫一扫