【数据结构】停车场管理问题 C语言代码【附带HDU数据结构实践报告】

欣欣草木生

已于 2023-02-02 15:15:02 修改

阅读量2.5k

点赞数 7

文章标签：数据结构 c语言服务器

于 2022-09-30 23:56:16 首次发布

本文链接：https://blog.csdn.net/m0_61809818/article/details/127115527

版权

一【问题描述】

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

二【设计要求】

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

三【问题分析】

【结构体定义】：
需要定义栈和队列。栈是顺序栈，队列是链式队列。

【逻辑分析】：
一：对于输入的数据的合法性判断包括以下两个方面
（其实合法性可能要判断很多但是本代码只考虑了以下这些暂时足够了）

1.输入的车的时间需要保证后一辆大于前一辆
添加一个preTime变量记录前一辆车的时间，每次进车都更新时间。

2.状态码只能是0或1

如果不合法提示输入错误

二：对于通过以上判断的数据，需根据状态码来进行不同的处理。

若状态码是0，代表进车，需要停车。

若状态码是1，代表出车，需要计费。
同时！需要将队列中的车添加到栈中并更新进去时候的时间的值！

在此可添加一个对于id的判断。
若进车必须保证里边没有同id的车，若出车必须保证里边有同id的车。
（虽说对于id重复的车那是假号牌，那是交警队的事情。）

四【代码详解】

输入的数据为一组三个数
第一个数是车的状态码（结构体中的state）：0/1代表进车/出车
第二个数是车的车牌号（结构体中的id）
第三个数是车的时间（结构体中的id）
车辆到达则输出位置，离去则输出停留时间和费用。

1【定义部分】

#include<stdio.h>
#include<math.h>
#define MAXSIZE 100//用来定义栈的最大值
#define portMaxCarNum 3//可以用来修改停车场可容纳最大车数量
typedef struct Car {
	int state;
	int id;
	int time;
	Car * next;//在链式结构时用来指向下一个 在栈中就当做不存在这个属性
} Car; //结构体 车

//栈定义
typedef struct {
	Car *base;
	int top;
} Stack;//结构体 顺序栈
//顺序栈的定义是一个基底指针和一个top值,取值的时候是以数组的形式,本来应该加个maxsize

//队列定义
typedef struct Queue {
	struct Car* front;//队头指针和队尾指针
	struct Car* rear;
} Queue;


void InitStack(Stack &S);//初始化栈,包括分配空间和初始赋值
void PushStack(Stack &S, Car C);//压栈
void PopStack(Stack &S, Car &C);//出栈
int OverStack(Stack S);//栈满判定
int findStack(Stack S, int &bef, int id);
//寻找栈中有无这个id,传入的bef用来顺便修改外部变量的值,值为该id的车前有几辆车
void addPortPos(Stack &S, Queue &Q, int time);//将车添加到队列中并更新时间
void backStackCar(Stack &Q, Stack &help, int num);//将停车场中需要出去的车之后的车都退到一个辅助栈中
void frontStackCar(Stack &Q, Stack &help, int num);//将辅助栈中的车再重新停回到停车场中


void InitQueue(Queue &Q);
void EnQueue(Queue &Q, Car C);
void DeQueue(Queue &Q, Car &C);
int EmptyQueue(Queue Q);
int findQueue(Queue Q, Car **p, int id);
//寻找队列中有无这个id的车 
//Car**p是为了顺便修改外部的变量,值为需要删除的节点的前一个节点的指针

void money(int time);//计算钱
void bookCarInStackOrQueue(Stack &S, Queue &Q, Car cc);//将后续的车补位

2【主函数】

int main() {
	//初始化
	int preTime = 0;
	Stack port;
	InitStack(port);
	Stack help;
	InitStack(help);
	Queue que;
	InitQueue(que);
	Car temp;
	temp.next = NULL;
	//打印提示
	printf("模拟停车场管理系统\n");
	printf("输入数据格式如下\n");
	printf("第一个数代表状态,第二个数代表车牌号,第三个数代表时间 例如\n");
	printf("0 1 2\n1 5 8\n");
	printf("请输入你的数据\n");
	//数据处理
	while (scanf("%d%d%d", &temp.state, &temp.id, &temp.time) != EOF) {
		//若时间错误
		if (temp.time < preTime)
			printf("车辆的时间小于前一辆车的时间,输入错误请重新输入\n");
		//若状态码错误
		else if (temp.state != 1 && temp.state != 0)
			printf("状态码输入错误(只能输入0或1),请重新输入\n");
		
		else {
			//状态码是1但是没该车 错误
			//状态码是0但是已有车 错误
			if (temp.state == 0) {
				Car *preCarPoint = NULL;//设置findStack和findQueue函数的时候传入了参数方便下边的停车操作
				int preCarNum;
				if (findStack(port, preCarNum, temp.id) || findQueue(que, &preCarPoint, temp.id))
					printf("车已存在,id重复\n");//返回值是1代表已存在
				else {
					preTime = temp.time; //更新最后一辆车的时间
					bookCarInStackOrQueue(port, que, temp);
				}
			} else if (temp.state == 1) {
				Car *preCarPoint = NULL;
				int preCarNum;
				int flag1 = findStack(port, preCarNum, temp.id);
				int flag2 = findQueue(que, &preCarPoint, temp.id);
				if (!flag1 && !flag2)//如果停车场中和通道中都找不到
					printf("车不存在,id输入错误\n");
				else {
					preTime = temp.time; //更新最后一辆车的时间
					if (flag1) {
						int carNum = port.top - preCarNum - 1;//需要移走carNum个车
						backStackCar(port, help, carNum);
						Car cc;
						PopStack(port, cc);
						printf("你停留的时间是%d\n", temp.time - cc.time);
						money(temp.time - cc.time);
						//重新压入停车场栈
						frontStackCar(port, help, carNum);
						addPortPos(port, que, temp.time);//将队列中的车压入栈
					} else if (flag2) {
						printf("id为%d的车在队列中找到\n", temp.id);
						printf("你停留的时间是%d 但是在通道不收费\n ", temp.time - preCarPoint->next->time);
						preCarPoint->next = preCarPoint->next->next;//将该车节点扔掉
						//读者可自行添加free这个节点的代码,没有释放空间有点不规范
					}
				}
			}
		}
	}
	return 0;
}

3【函数实现】

//顺序栈
void InitStack(Stack &S) {
	S.base = (Car*)malloc(sizeof(Car) * MAXSIZE);
	S.top = 0;
}
void PushStack(Stack &S, Car C) {
	S.base[S.top++] = C;
}
void PopStack(Stack &S, Car &C) {
	C = S.base[--S.top];
}
int OverStack(Stack S) {
	if (S.top == portMaxCarNum) {
		return 1;
	} else
		return 0;
}

//链式队列
void InitQueue(Queue &Q) {
	Q.front = Q.rear = (Car*)malloc(sizeof(Car));
	//以队头指针的人下一个元素才是真正的第一个数据
	Q.rear->next = NULL;
}
void EnQueue(Queue &Q, Car C) {
	Car *p = (Car*)malloc(sizeof(Car));
	*p = C;
	Q.rear->next = p;
	Q.rear = p;
}
void DeQueue(Queue &Q, Car &C) {
	Car*p = Q.front->next;
	C = *p;
	Q.front->next = p->next;
	//关于出队列要注意这个if判断 否则rear就被丢掉了
	if (p == Q.rear) {
		Q.rear = Q.front;
	}
	free(p);
}
int EmptyQueue(Queue Q) {
	if (Q.front == Q.rear) {
		return 1;
	} else return 0;
}

void addPortPos(Stack &S, Queue &Q, int newTime) {
	//要判断通道有没有车 有的话添加 没有的话 不加
	if (EmptyQueue(Q)) {
		printf("通道中无车无需补位\n");
		return;
		//时间改变
	} else {
		Car cc;
		DeQueue(Q, cc);
		PushStack(S, cc);
		S.base[S.top - 1].time = newTime;
		printf("后边车辆补位成功并已更新停车时间\n");
	}
}

int findStack(Stack S, int &bef, int id) {
	int idx = 0;
	while (idx < S.top) {
		if (S.base[idx].id == id) {
			bef = idx;
			printf("id为%d的车在栈中找到\n", id);
			return 1;
		}
		idx++;
	}
	return 0;
}
void money(int time) {
	if (time < 10) {
		printf("未满十分钟不计费\n");

	} else
		printf("超过十分钟每分钟计费一元\n你需要付费%d元\n", time - 10);

}
//停车操作
void bookCarInStackOrQueue(Stack &port, Queue &que, Car temp) {
	
	if (!OverStack(port)) {
		PushStack(port, temp);
		printf("id为%d的车已停车至停车场\n", temp.id);
	} else {
		EnQueue(que, temp);
		printf("id为%d的车已停车至通道\n", temp.id);
	}
}
//修改car**p 修改传入的指针的值
int findQueue(Queue Q, Car **p,int id) {
	Car *p1,*p2;
	p1 = Q.front;
	p2 = Q.front->next;	
	while (p2!= NULL) {
		if (p2->id == id) {
			*p=p1;
			return 1;
		}
		p1 = p2;
		p2 = p2->next;
	}
	return 0;

}

void backStackCar(Stack &Q, Stack &help, int num) {
	Car cc;
	while (num--) {
		PopStack(Q, cc);
		PushStack(help, cc);
	}
}
void frontStackCar(Stack &Q, Stack &help, int num) {
	Car cc;
	while (num--) {
		PopStack(help, cc);
		PushStack(Q, cc);
	}
}

五、【更新了数据结构实践报告】

一、需求分析

1、设停车场是一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列(大门在最南端，最先到达的第一辆车停放在车场的最北端)，若车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车场为它让路，待该车辆开出大门外，其它车辆再按照原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。试为停车场编制按上述要求进行管理的模拟程序。
2、以栈模拟停车场，以队列模拟车场外的便道，栈以顺序存储结构实现，队列以链表存储结构实现。
3、按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去的时刻。对每一组输入数据进行操作后的输出信息为：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用(在便道上停留的时间不收费，便道上的车辆也可直接开走)。
4、测试数据
0 2 0
0 3 0
0 4 0
0 5 0
0 6 0
0 7 0
0 8 0
0 9 0
0 10 0
0 11 0
1 1 10
1 2 20
1 5 30

二、概要设计

为了实现以上程序功能，应构造对应的栈来模拟模拟停车场，以队列模拟车场外的便道。
1、设置栈的抽象数据类型定义
ADT Stack {
数据对象：
D = {ai | ai ∈ ElemSet，i = 1,2,3,…,n, n ≥ 0}
// ElemSet 表示元素的集合
数据关系：
R1={<ai-1, ai> | ai-1 , ai∈D，i=2，…，n}
// ai-1为前驱，ai为后继

基本操作：初始化、进栈、出栈、取栈顶元素等
InitStack（&S）初始化操作
操作结果：构造一个空栈 S

DestroyStack（&S）销毁栈操作
初始条件：栈S已存在
操作结果：栈S被销毁

StackEmpty（S）判定栈是否为空栈
初始条件：栈S已存在
操作结果：若栈S为空栈，则返回TRUE，

StackLength（S）求栈的长度
初始条件：栈S已存在
操作结果：返回栈S的元素个数，即栈的长度

GetTop（S，&e）取栈顶元素
初始条件：栈S已存在且非空
操作结果：用e返回S的栈顶元素

ClearStack（&S）栈指控操作
初始条件：栈S已存在
操作结果：将S清为空栈

Push（&S，e）入栈操作
初始条件：栈S已存在
操作结果：插入元素e为新的栈顶元素

Pop（&S，&e）出栈操作
初始条件：栈S存在且非空
操作结果：删除栈SD栈顶元素an，并用e返回其值
} ADT Stack
2、设置队列的抽象数据类型定义
ADT Queue{
数据对象: D= {a0,a1,a2…an, ai都是同一数据类型的元素}
数据关系: R = {<ai, ai+1>}
数据操作:
getSize() : 返回元素的个数
isEmpty(): 判断队列是否为空
enQueue(e):入队
deQueue(): 出队
peek(): 返回队首的元素
}ADT Queue

3、本程序包含以下三个模块
（1）主程序模块
（2）栈模块——实现栈抽象数据类型
（3）队列模块——实现排队车流抽象数据类型

4、每输入一辆车的信息，返回其状态（包括停车信息，停车金额等等）

三、详细设计

1、汽车结构体
typedef struct Car {
int state;
int id;
int time;
Car * next;
} Car; //结构体车

2、栈类型
typedef struct {
Car *base;
int top;
} Stack;//结构体顺序栈
栈的基本操作：
void InitStack(Stack &S);
void PushStack(Stack &S, Car C);
void PopStack(Stack &S, Car &C);
int OverStack(Stack S);
int findStack(Stack S, int &bef, int id);

3、队列类型
typedef struct Queue {
struct Car* front;//队头指针和队尾指针
struct Car* rear;
} Queue;
队列的基本操作：
void InitQueue(Queue &Q);
void EnQueue(Queue &Q, Car C);
void DeQueue(Queue &Q, Car &C);
int EmptyQueue(Queue Q);
int findQueue(Queue Q, Car **p, int id);

4、栈与队列的交互操作
void addPortPos(Stack &S, Queue &Q, int time);
void backStackCar(Stack &Q, Stack &help, int num);
void frontStackCar(Stack &Q, Stack &help, int num);

5、主函数

int main() {
    //初始化
    int preTime = 0;
    Stack port;
    InitStack(port);
    Stack help;
    InitStack(help);
    Queue que;
    InitQueue(que);
    Car temp;
    temp.next = NULL;
    
    printf("模拟停车场管理系统\n");
    printf("输入数据格式如下\n");
    printf("第一个数代表状态,第二个数代表车牌号,第三个数代表时间 例如\n");
    printf("0 1 2\n1 5 8\n");
    printf("请输入你的数据\n");
    while (scanf("%d%d%d", &temp.state, &temp.id, &temp.time) != EOF) {
        //时间错误
        if (temp.time < preTime)
            printf("车辆的时间小于前一辆车的时间,输入错误请重新输入\n");
        else if (temp.state != 1 && temp.state != 0)
            printf("状态码输入错误(只能输入0或1),请重新输入\n");
        //状态码是1但是没该车 错误
        //状态码是0但是已有车 错误
        else {
            if (temp.state == 0) {
                Car *preCarPoint = NULL;//preCarPoint和preCarNum都是随便起的 主要是设置findStack和findQueue函数的时候传入了参数方便下边的停车操作
                int preCarNum;
                if (findStack(port, preCarNum, temp.id) || findQueue(que, &preCarPoint, temp.id))
                    printf("车已存在,id重复\n");//返回值是1代表已存在
                else {
                    preTime = temp.time; //更新最后一辆车的时间
                    bookCarInStackOrQueue(port, que, temp);
                }
            } else if (temp.state == 1) {
                Car *preCarPoint = NULL;
                int preCarNum;
                int flag1 = findStack(port, preCarNum, temp.id);
                int flag2 = findQueue(que, &preCarPoint, temp.id);
                if (!flag1 && !flag2)
                    printf("车不存在,id输入错误\n");
                //idx表示前面有几个车
                else {
                    preTime = temp.time; //更新最后一辆车的时间
                    if (flag1) {
                        int carNum = port.top - preCarNum - 1;//需要移走carNum个车
                        backStackCar(port, help, carNum);
                        Car cc;
                        PopStack(port, cc);
                        printf("你停留的时间是%d\n", temp.time - cc.time);
                        money(temp.time - cc.time);
                        //重新压入停车场栈
                        frontStackCar(port, help, carNum);
                        addPortPos(port, que, temp.time);//将队列中的车压入栈
                    } else if (flag2) {
                        printf("id为%d的车在队列中找到\n", temp.id);
                        printf("你停留的时间是%d 但是在通道不收费\n ", temp.time - preCarPoint->next->time);
                        preCarPoint->next = preCarPoint->next->next;
                    }
                }
            }
        }
    }
    return 0;
}

四、调试分析

1、本次作业比较简单，核心的问题就在于对各种非法情况的处理（例如：车牌号重复，车未进先出等等情况）
2、以队头指针的人下一个元素才是真正的第一个数据，切忌弄混。
3、写出队列的函数时要注意 if (p == Q.rear) {Q.rear = Q.front;}，否则造成空指针错误。
4、经验体会：借助debug调试器和数据观察窗口，可以加快找到程序中瑕疵。

五、用户手册

1、本程序的运行环境为DOS操作系统，执行文件为停车场管理.exe。
2、进入演示程序后，即显示文本方式的用户界面。
在这里插入图片描述

3、每输入一辆车的信息便返回该辆车的状态
在这里插入图片描述

4、如果停车场的车出来，计算停车费用（可自由调节计算函数）

在这里插入图片描述

六、测试结果

七、心得体会

1、熟练掌握调试的方法可以大大节约debug的时间
2、要注意对于一些判断语句的封装，否则代码会难以复用且不易于理解。
3、本程序对于信息记录完整，包括车辆的入场时间、出场时间、停车时长、收费金额等信息，便于统计分析。
4、本程序安全可靠，考虑了重复车牌的问题（例：有一辆车在未离开停车场的时候又进来一辆相同车牌id的车），可与交管所进行合作，帮助制止重复号牌的违法行为。
5、通过本次实践，我深刻地体会到了程序员们写代码的不易，加班加点赶系统，促使我更好地安排平时时间，注重身心健康，早睡早起。充沛的精力与强健的体魄是一个优秀计算机从业者不可缺少的东西。我也体会到了一个程序要做到尽善尽美需要考虑很多很多的要素，既要能做成，还要做的好，让代码通俗易懂。更有程序中碰到的号牌重复的问题，引发了我对于车管方面的思考，激发了我投身于车管安全的热情与信心。相信随着技术的完善，各行各业都会更加高效。

六完整代码如下

#include<stdio.h>
#include<math.h>
#define MAXSIZE 100
#define portMaxCarNum 3
/*
20220929星期四17:16
周伟欣
*/
//出队列那里关于p与rear的判等很重要,不能直接free p

/*
	整体逻辑如下
	1 根据state值判断是停车还是出车
	若停车:需根据停车场的栈满情况决定停车位置
	若出车:涉及到	1.停车费的计算  2.后边车的补位
*/

/*
要求:
栈以顺序存储    停车场 和 辅助栈
队列链式存储    通道
state           0到达 1离去
id 				车牌号
time 			到达或者离去的时刻
到达则输出位置
离去则输出停留时间和费用
*/

/*
测试数据 到达 id为1 时间为0
//进车的时间先后 修改进车时间 入车重复判断
0 2 0
0 3 0
0 4 0
0 5 0
0 6 0
0 7 0
0 8 0
0 9 0
0 10 0
0 11 0
1 1 10
1 2 20
1 5 30
*/


typedef struct Car {
	int state;
	int id;
	int time;
	Car * next;
} Car; //结构体 车

typedef struct {
	Car *base;
	int top;
} Stack;//结构体 顺序栈

//队列
typedef struct Queue {
	struct Car* front;//队头指针和队尾指针
	struct Car* rear;
} Queue;


void InitStack(Stack &S);
void PushStack(Stack &S, Car C);
void PopStack(Stack &S, Car &C);
int OverStack(Stack S);
int findStack(Stack S, int &bef, int id);
void addPortPos(Stack &S, Queue &Q, int time);
void backStackCar(Stack &Q, Stack &help, int num);
void frontStackCar(Stack &Q, Stack &help, int num);

void InitQueue(Queue &Q);
void EnQueue(Queue &Q, Car C);
void DeQueue(Queue &Q, Car &C);
int EmptyQueue(Queue Q);
int findQueue(Queue Q, Car **p, int id);

void money(int time);
void bookCarInStackOrQueue(Stack &S, Queue &Q, Car cc);

int main() {
	//初始化
	int preTime = 0;
	Stack port;
	InitStack(port);
	Stack help;
	InitStack(help);
	Queue que;
	InitQueue(que);
	Car temp;
	temp.next = NULL;
	
	printf("模拟停车场管理系统\n");
	printf("输入数据格式如下\n");
	printf("第一个数代表状态,第二个数代表车牌号,第三个数代表时间 例如\n");
	printf("0 1 2\n1 5 8\n");
	printf("请输入你的数据\n");
	while (scanf("%d%d%d", &temp.state, &temp.id, &temp.time) != EOF) {
		//时间错误
		if (temp.time < preTime)
			printf("车辆的时间小于前一辆车的时间,输入错误请重新输入\n");
		else if (temp.state != 1 && temp.state != 0)
			printf("状态码输入错误(只能输入0或1),请重新输入\n");
		//状态码是1但是没该车 错误
		//状态码是0但是已有车 错误
		else {
			if (temp.state == 0) {
				Car *preCarPoint = NULL;//preCarPoint和preCarNum都是随便起的 主要是设置findStack和findQueue函数的时候传入了参数方便下边的停车操作
				int preCarNum;
				if (findStack(port, preCarNum, temp.id) || findQueue(que, &preCarPoint, temp.id))
					printf("车已存在,id重复\n");//返回值是1代表已存在
				else {
					preTime = temp.time; //更新最后一辆车的时间
					bookCarInStackOrQueue(port, que, temp);
				}
			} else if (temp.state == 1) {
				Car *preCarPoint = NULL;
				int preCarNum;
				int flag1 = findStack(port, preCarNum, temp.id);
				int flag2 = findQueue(que, &preCarPoint, temp.id);
				if (!flag1 && !flag2)
					printf("车不存在,id输入错误\n");
				//idx表示前面有几个车
				else {
					preTime = temp.time; //更新最后一辆车的时间
					if (flag1) {
						int carNum = port.top - preCarNum - 1;//需要移走carNum个车
						backStackCar(port, help, carNum);
						Car cc;
						PopStack(port, cc);
						printf("你停留的时间是%d\n", temp.time - cc.time);
						money(temp.time - cc.time);
						//重新压入停车场栈
						frontStackCar(port, help, carNum);
						addPortPos(port, que, temp.time);//将队列中的车压入栈
					} else if (flag2) {
						printf("id为%d的车在队列中找到\n", temp.id);
						printf("你停留的时间是%d 但是在通道不收费\n ", temp.time - preCarPoint->next->time);
						preCarPoint->next = preCarPoint->next->next;
					}
				}
			}
		}
	}
	return 0;
}
//顺序栈
void InitStack(Stack &S) {
	S.base = (Car*)malloc(sizeof(Car) * MAXSIZE);
	S.top = 0;
}
void PushStack(Stack &S, Car C) {
	S.base[S.top++] = C;
}
void PopStack(Stack &S, Car &C) {
	C = S.base[--S.top];
}
int OverStack(Stack S) {
	if (S.top == portMaxCarNum) {
		return 1;
	} else
		return 0;
}

//链式队列
void InitQueue(Queue &Q) {
	Q.front = Q.rear = (Car*)malloc(sizeof(Car));
	//以队头指针的人下一个元素才是真正的第一个数据
	Q.rear->next = NULL;
}
void EnQueue(Queue &Q, Car C) {
	Car *p = (Car*)malloc(sizeof(Car));
	*p = C;
	Q.rear->next = p;
	Q.rear = p;
}
void DeQueue(Queue &Q, Car &C) {
	//关于出队列要注意 两个NULL (下方if中的内容)
	Car*p = Q.front->next;
	C = *p;
	Q.front->next = p->next;
	if (p == Q.rear) {
		Q.rear = Q.front;
	}
	free(p);
}
int EmptyQueue(Queue Q) {
	if (Q.front == Q.rear) {
		return 1;
	} else return 0;
}

void addPortPos(Stack &S, Queue &Q, int newTime) {
	//要判断通道有没有车 有的话添加 没有的话 不加了
	if (EmptyQueue(Q)) {
		printf("通道中无车无需补位\n");
		return;
		//时间改变
	} else {
		Car cc;
		DeQueue(Q, cc);
		PushStack(S, cc);
		S.base[S.top - 1].time = newTime;
		printf("后边车辆补位成功并已更新停车时间\n");
	}
}

int findStack(Stack S, int &bef, int id) {
	int idx = 0;
	while (idx < S.top) {
		if (S.base[idx].id == id) {
			bef = idx;
			printf("id为%d的车在栈中找到\n", id);
			return 1;
		}
		idx++;
	}
	return 0;
}
void money(int time) {
	if (time < 10) {
		printf("未满十分钟不计费\n");

	} else
		printf("超过十分钟每分钟计费一元\n你需要付费%d元\n", time - 10);

}
//停车操作
void bookCarInStackOrQueue(Stack &port, Queue &que, Car temp) {
	
	if (!OverStack(port)) {
		PushStack(port, temp);
		printf("id为%d的车已停车至停车场\n", temp.id);
	} else {
		EnQueue(que, temp);
		printf("id为%d的车已停车至通道\n", temp.id);
	}
}
//修改car**p 修改传入的指针的值
int findQueue(Queue Q, Car **p,int id) {
	Car *p1,*p2;
	p1 = Q.front;
	p2 = Q.front->next;	
	while (p2!= NULL) {
		if (p2->id == id) {
			*p=p1;
			return 1;
		}
		p1 = p2;
		p2 = p2->next;
	}
	return 0;

}

void backStackCar(Stack &Q, Stack &help, int num) {
	Car cc;
	while (num--) {
		PopStack(Q, cc);
		PushStack(help, cc);
	}
}
void frontStackCar(Stack &Q, Stack &help, int num) {
	Car cc;
	while (num--) {
		PopStack(help, cc);
		PushStack(Q, cc);
	}
}