C/C++用栈和队列实现停车场问题

问题：设停车场内只有一个可停放 n 辆汽车的狭长通道，且只有一个大门可供汽车进出，汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满 n 辆汽车，则后来的汽车只能在门外的便道上等候, 一旦有车开走，则排在便道上的第一辆车即可开入，当停车场内某辆车要离开时，在它之后开入的车辆必须先退出车场为它让路，待该辆车开出大门外，其它车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用，当便道上汽车要离开时，排在它前面的汽车要先开走让路，然后再依次排到队尾，并且在便道上停车不收费。试为停车场编制按上述要求进行管理的模拟程序。

问题用代码分析：以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列管理，每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时间，对每一组输入数据进行操作后的输出数据为： 若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用（在便递上停留的时间不收费），栈以顺序结构实现，队列以链表结构实现。

       需另设一栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车，也用顺序存储结构实现。输入数据按到达或离去的时刻有序。栈中每个元素表示一辆汽车，包含有两个数据项：汽车牌照号码和进入停车场的时间。

代码实现：

主函数：

#include"标头.h"
using namespace std;
int main()
{
	LinkQueue Q;//表示便道
	SqStack S,DS;//S表示停车场，DS表示辅助停车场
	cout << "停车场最多可停放车辆数以及单位时间的停车费用" << endl;
	int num,i;
	Data _data;
	double fee;
	cin >> num >> fee;
	InitQNode(Q);//初始化便道
	InitStack(S, num);//初始化停车场
	InitStack(DS, num);//初始化辅助停车场
	while (true)
	{	
		cin >> _data.in >> _data.number >> _data.time;
		if (_data.in == 0 && _data.number == 0 && _data.time == 0)//若输入的为0 0 0结束循环 
			break;
		if (_data.in == 0)//若为0则有车进入停车场
		{
			if (!pushStack(S, _data))//进入停车场，若车满了返回0，执行主体
			{
				cout << "进便道" << endl;
				EnQueue(Q, _data);//进入便道
			}
		}
		else//in==1 有车要出去
		{
			if (!findInCar(S, DS, _data.number, fee,_data.time))//在停车场查找，若没找到返回0；
			{
				findOutCar(Q, _data.number);//在便道里查找
			}
			else//在停车场找到，便道里的第一个车进入
			{
				if (Q.front->next)
				{
					cout << "便道里的车进停车场" << endl;
					pushStack(S, Q.front->next->_data);
					cout << "当前便道里的车牌号" << endl;
					DeQueue(Q);	
				}	
			}
		}	
	}
	DisShuju();//输出出停车场的车牌号和费用
	DisStack(S);//输出停车场车的数据
	cout << endl;
	DisQueue(Q);//输出便道车的数据
	return 0;
}

头文件

#pragma once
#include<iostream>
#define  OK 1;
#define  ERROR 0;
typedef  int status;
int static NUM=0;
 struct Data
{
	int in;//（0）进还是（1）出 
	int time;//进出的时间
	int number;//车牌号
};
 struct pushData
 {
	 int num;//车牌号
	 double fee;//费用
 };
typedef struct 
{
	Data* base;
	Data* top;
	int stacksize;
}SqStack;//栈的实现
typedef struct QNode
{
	Data _data;
	struct  QNode* next;
}QNode,*QueuePtr;
typedef struct
{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;//队列的实现
status InitStack(SqStack &S, int num);//初始化栈
status pushStack(SqStack& S, Data e);//进栈
status popStack(SqStack& S, Data& e);//出栈，e表示出栈的数据
status popStack(SqStack& S);//出栈，无出栈的数据
status findInCar(SqStack& S, SqStack& DS, int num, double fee,int time);//查找到在停车场对应车牌号的车，若没找到返回0
status InitQNode(LinkQueue& Q);//初始化队列
status EnQueue(LinkQueue& Q, Data  e);//进队列
status DeQueue(LinkQueue& Q, Data& e);//出队列，e表示出队列的数据
status DeQueue(LinkQueue& Q);//出队列，没有出队列的数据（函数的重载）
status findOutCar(LinkQueue& Q, int num);//查找到在车道上对应车牌号的车，若没找到返回0
void DisStack(SqStack S);//显示停车场里车的车牌号
void DisQueue(LinkQueue Q);//显示车道里车的车牌号
void DisShuju();//显示出去车的车牌号和费用

函数的定义

#include"标头.h"
using namespace std;
pushData shuju[10];//用于存储出停车场车的车牌号和费用
status InitStack(SqStack &S, int num)
{
	S.base = (Data*)malloc((num+1) * sizeof(Data));
	if (!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = num;
	return OK;
}
 status pushStack(SqStack& S,Data e)
{
	 if (S.top - S.base >= S.stacksize)
		 return ERROR;
	 *S.top=e;
	 S.top++;
	 DisStack(S);
	 cout << endl;
	 return OK;
}
status popStack(SqStack& S,Data &e)  
 {
	if (S.top == S.base)
		return ERROR;
	e = *(--S.top);
	
	cout <<e.number<< endl;
	return  OK;
}
status popStack(SqStack& S)
{
	if (S.top == S.base)
		return ERROR;
	--S.top;
	DisStack(S);
	cout << endl;
	return  OK;
}
status findInCar(SqStack& S, SqStack& DS, int num,double fee,int time)
{
	Data q;
	int m=1,n=1;
	cout << "使用备用停车场" << endl;
	while ((S.top-1)->number != num&&S.top!=S.base)
	{
	
		popStack(S,q);
		pushStack(DS, q);
	}
	
	if (S.top == S.base)
	{
		m = 0;
		n = 0;
	}
	else {
		cout << "成功出停车场";
		popStack(S, q);
	}
	
	if (n != 0)
	{
		shuju[NUM].fee = (time - q.time) * fee;
		shuju[NUM].num = num;
		NUM++;
	}
		
	
	while (DS.top != DS.base)
	{
		popStack(DS, q);
		pushStack(S, q);
	}
	cout << "备用停车场使用结束" << endl;
	return m;
}
status InitQNode(LinkQueue& Q)
{
	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
	if (!Q.front)return 0;
	else
	{
		Q.front->next = NULL;
	}

	return OK;
}
status EnQueue(LinkQueue& Q, Data  e)
{
	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
	if (!p)exit(OVERFLOW);
	p->_data = e;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	DisQueue(Q);
	cout << endl;
	return OK;
}

status DeQueue(LinkQueue& Q, Data& e)
{
	if (Q.front == Q.rear)
		return ERROR;
	QueuePtr p = Q.front->next;
	e = p->_data;
	Q.front->next = p->next;
	
	if (Q.rear == p)
		Q.rear = Q.front;
	cout <<p->_data.number<< endl;
	free(p);
	return OK;
}
status DeQueue(LinkQueue& Q)
{
	if (Q.front == Q.rear)
		return ERROR;
	QueuePtr p = Q.front->next;
	Q.front->next = p->next;

	if (Q.rear == p)
		Q.rear = Q.front;
	free(p);
	DisQueue(Q);
	cout << endl;
	return OK;
}
status findOutCar(LinkQueue& Q ,int num)
{

	Data q;
	if (Q.front->next)
	{
		while (Q.front->next->_data.number != num)
		{
			cout << "便道要出车的前面" << endl;
			DeQueue(Q, q);
			cout << "前面的车进入后面" << endl;
			EnQueue(Q, q);
		}
		cout << "便道里的车成功出车" << endl;
		DeQueue(Q);
	}

		return OK;	
}
void DisStack(SqStack S)  
{
	int i;
	while(S.top!=S.base)
	{ 
		
		cout << S.base->number << " ";
		S.base++;
	}	
}
void DisQueue(LinkQueue Q)
{
	while (Q.front != Q.rear)
	{
		Q.front = Q.front->next;
		cout << Q.front->_data.number<<" ";
		
	}
	
}
void DisShuju()
{
	int i;
	for (i = 0; i < NUM; i++)
	{

		cout << shuju[i].num << " " << shuju[i].fee << endl;
	}
}