停车场管理系统（栈和队列的实现和应用）（cpp)

1.实验内容

编制一个程序来模拟停车场的管理过程。
设有一个可以停放n辆汽车的狭长停车场，它只有一个大门供车辆进出。车辆按到达停车场的先后次序停放在停车场中（最先到达的第一辆车停在停车场的最里面） 。如果停车场已停满n辆车，则后来的车辆只能在停车场大门外的便道上等待，一旦停车场内有车开走，则排在便道上的第一辆车就可进入停车场。停车场内如果有某辆车要开走，在它之后进入停车场的车辆都必须先退出停车场为它让路，待其开出停车场后，再依照原来的次序进入。每辆车离开停车场时，根据自己在停车场内停留的时间交费。如果停在便道上的车辆未进入停车场就要离去，其离去时不交停车费，并且在便道上等待的车辆保持原来的次序。

实验步骤及要求：
（1）首先，确定模拟程序需要的数据结构及其操作。停车场只有一个大门，可用一个栈S1来模拟；便道上，先排队的车辆先离开便道进入停车场，可用一个队列来模拟；排在停车场中间的车辆可以提前离开，还需要一个地方（车辆规避所）停放为了让路离开停车场的车辆，这也需要一个栈来模拟。
（2）在程序执行的过程中，当输入数据表示有车辆到达时，判断栈S1是否已满，若未满，就使新数据进栈S1；若已满，就使新数据进入队列Q，表示车辆在便道上等待进入停车场。
（3）当输入数据表示有车辆要离去时，就在栈S1中寻找对应车牌号的车辆，若找到，就让其离开停车场，并根据停车时间计费，同时使队列Q的队头元素进入栈S1；若没找到，就在队列Q中寻找此车牌号的车辆，若在队列Q中找到，则允许其离开队列，并且不收费；若找不到，就显示出错信息；当离开停车场的车辆位于栈S1的中间时，必须先将此位置与栈顶之间的所有数据倒放到栈S2中去，然后安排车辆离开栈S1，最后将栈S2的数据倒放至栈S1中。
（4）以上操作需要利用栈的入栈和出栈以及队列的入队和出队操作来实现。
（5）要求实现栈类和队列类，在主函数中实例化类的对象，输入相应数据，设置菜单选择项来模拟停车场的管理过程。

2.代码（cpp)

CarPark.h

const int MaxSize = 5;      //停车场容量

class CarSt {
private:
	char car[MaxSize][10];
	int top;
public:
	CarSt();				//构造函数
	int Size();				//栈长
	bool IsFull();			//判断栈满
	bool IsEmpty();			//判断栈空
	bool Push(char c[]);    //入栈
	bool Pop();				//出栈
	int find(char c[]);		//查找
	char* Top();			//返回栈顶元素
	void print();			//打印栈元素
};

struct Node {
	char car[10];
	Node *next;
};

class CarQu {
private:
	Node *t, *w;
public:
	CarQu();				//构造函数
	bool IsEmpty();			//判断队列为空
	void Push(char c[]);	//入队列
	bool Pop();				//出队列
	Node * find(char c[]);  //查找
	char * front();			//返回头元素
	void print();			//打印队列元素
};

CarPark.cpp

#include <iostream>
#include "CarPark.h"
using namespace std;

//构造函数
CarSt::CarSt() {
	for (int i = 0; i < 10; i++)
		car[MaxSize-1][i] = {'\0'};
	top = -1;
}

//栈长
int CarSt::Size() {
	return top+1;
}

//判断栈满，栈满返回ture
bool CarSt::IsFull() {
	return top == MaxSize - 1;
}

//判断栈空，栈空返回ture
bool CarSt::IsEmpty() {
	return top == -1;
}

//入栈
bool CarSt::Push(char c[]) {
	if (IsFull()) return false;
	top++;
	for (int i = 0; i < strlen(c); i++) {
		car[top][i] = c[i];
	}
	car[top][strlen(c)] = '\0';
	return true;
}

//出栈
bool CarSt::Pop() {
	if (IsEmpty()) return false;
	top--;
	return true;
}

//查找
int CarSt::find(char c[]) {
	for (int i = 0; i <= top; i++) {
		int tmp = 0;
		for (int j = 0; j < strlen(c); j++) {
			if (c[j] != car[i][j]) break;
			else tmp++;
		}
		if (tmp == strlen(c)) return i;
	}
	return -1;
}

//返回栈顶元素
char * CarSt::Top() {
	return car[top];
}

//打印栈元素
void CarSt::print() {
	for (int i = 0; i <= top; i++) {
		printf("%s\n", car[i]);
	}
}

//构造函数
CarQu::CarQu() {
	t = NULL;
	w = NULL;
}

//判断队列为空，为空返回ture
bool CarQu::IsEmpty() {
	return t == NULL;
}

//入队列
void CarQu::Push(char c[]) {
	Node* p = new Node;
	for (int i = 0; i < strlen(c); i++)
		p->car[i] = c[i];
	p->car[strlen(c)] = '\0';
	p->next = NULL;
	if (t == NULL) {
		t = p;
		w = p;
	}
	else {
		w->next = p;
		w = p;
	}
}

//出队列
bool CarQu::Pop() {
	if (IsEmpty()) return false;
	
	if (t->next == NULL) {
		t = NULL;
		w = NULL;
	}
	else {
		t = t->next;
	}
	return true;
}

//查找
Node * CarQu::find(char c[]) {
	if (IsEmpty()) return NULL;
	Node* p = t;
	while (p != NULL) {
		int tmp = 0;
		for (int i = 0; i < strlen(c); i++) {
			if (p->car[i] != c[i]) break;
			else tmp++;
		}
		if (tmp == strlen(c)) return p;
		else p = p->next;
	}
	return NULL;
}

//返回头元素
char * CarQu::front() {
	return t->car;
}

//打印队列元素
void CarQu::print() {
	Node* p = t;
	while (p != NULL) {
		printf("%s\n", p->car);
		p = p->next;
	}
}

main.cpp

#include <iostream>
#include "CarPark.h"
using namespace std;

//比较字符串，相同返回true
int f(char * x, char * y) {
	while (*y != '\0') {
		if (*x != *y) return false;
		x++, y++;
	}
	return true;
}

int main() {
	cout << "********************" << endl;
	cout << "*       菜单：     *" << endl;
	cout << "* 1.车辆到达停车场 *" << endl;
	cout << "* 2.车辆离开停车场 *" << endl;
	cout << "* 3.打印车辆车牌号 *" << endl;
	cout << "* 4.退出           *" << endl;
	cout << "********************" << endl;

	CarSt S1, S2;
	CarQu Q;

	int op;
	while (true) {
		cout << "\n请选择管理措施选项:";
		cin >> op;
		char c[10] = { '\0' };
		switch (op) {
			case 1:
				//车辆到达停车场
				cout << "请输入车牌号：";
				cin >> c;
				if (!S1.Push(c)) Q.Push(c);
				break;
			case 2: {
				//车辆离开停车场
				cout << "请输入车牌号：";
				cin >> c;
				int x = S1.find(c);
				if (x == -1) {
					Node* p = Q.find(c);
					if (p == NULL) {
						cout << "没有此车牌号的车辆" << endl;
					}
					else {
						while (!f(Q.front(), p->car)) {
							Q.Push(Q.front());
							Q.Pop();
						}
						if (Q.front() == p->car) Q.Pop();
					}
				}
				else {
					if (!Q.IsEmpty()) {
						S2.Push(Q.front());
						Q.Pop();
					}
					for (int i = S1.Size() - 1; i > x; i--) {
						S2.Push(S1.Top());
						S1.Pop();
					}
					S1.Pop();
					while (!S2.IsEmpty()) {
						S1.Push(S2.Top());
						S2.Pop();
					}
				}
				break;
			}
			case 3:
				//打印车辆车牌号
				if (S1.IsEmpty()) {
					cout << "停车场没有车辆"<<endl;
					break;
				}
				cout << "位于停车场的车辆：" << endl;
				S1.print();
				if (!Q.IsEmpty()) {
					cout << "位于便道的车辆" <<endl;
					Q.print();
				}
				break;
			case 4:
				//退出
				return 0;
			default:
				cout << "输入错误，请重新输入！" << endl;
				break;
		}
	}
	return 0;
}

3.总结

主要模拟了栈和队列，运用了封装。

ps:能力有限，代码多有不足。比如未根据停车时间计费。