• ＜数据结构＞停车场管理系统，利用栈和队列实现，包含纯c语言版和C++版的全注释源码

    ✨写在前面

            数据结构的课程设计一般都不是很好理解，于是我花时间总结了一下c和c++版本的常见栈和队列的的停车场管理程序。划重点，全注释！！！爆肝一天，绝对让你思路清晰的拿下该程序。

           ✨✨ 感兴趣的同学可以订阅一下我的这个《数据结构用心学》专栏喔~✨✨

    ✨目录

    纯c语言版

    包含的功能

    运行效果

    源码

    c++版

    包含的功能

    运行效果

    源码

    ✨写在后面

    纯c语言版

    包含的功能

    1、停车功能

            如果停车场满，能够暂时存放到便道内

    2、开走车功能

            将指定车开走后打印收据，便道内的车自动停到停车场

    3、退出程序功能

    运行效果

    停车功能测试：

    离开停车场并打印收据测试：

    源码

    1. #define _CRT_SECURE_NO_WARNINGS//visual stduio添加对scanf的信任
    2. #include<stdio.h>
    3. #include <stdlib.h>
    4. #include<string.h>
    5. #include<math.h>
    6. #define size 1 //停车场位置数
    7. //模拟停车场的堆栈的性质；
    8. typedef struct zanlind {
    9. 	int number; //汽车车号
    10. 	float ar_time; //汽车到达时间
    11. }zanInode;//车结点
    12. typedef struct {
    13. 	zanInode* base; //停车场的堆栈底
    14. 	zanInode* top; //停车场的堆栈顶
    15. 	int stacksize_curren;//堆栈长度
    16. }stackhead;
    17. //堆栈的基本操作；
    18. void initstack(stackhead& L) //构造一个空栈L
    19. {
    20. 	L.base = (zanInode*)malloc(size * sizeof(zanlind));//给栈L分配空间
    21. 	if (!L.base) exit(0);  //存储分配失败
    22. 	L.top = L.base;//初始化栈顶和栈底指针相同
    23. 	L.stacksize_curren = 0;//初始化栈长度为0
    24. }
    25. void push(stackhead& L, zanInode e) //插入元素e为新的栈顶元素
    26. {
    27. 	*L.top++ = e;//先让L栈的栈顶指向e,然后栈顶指针+1
    28. 	L.stacksize_curren++;//由于上面的e进入了栈内,所以栈长度加一
    29. }
    30. void pop(stackhead& L, zanInode& e) //若栈不为空,删除L的栈顶元素,用e返回其值
    31. {
    32. 	if (L.base==L.top)//栈长度为0时，停车场为空
    33. 	{
    34. 		printf("停车场为空!!");
    35. 		return;
    36. 	}
    37. 	e = *--L.top;//如果栈顶和栈底不等，那么e为当前top指针减一后的指向，这是因为栈顶指针始终指向栈顶元素的上面。
    38. 	L.stacksize_curren--;//随着top指针减一，栈长度减一。注意返回e是通过引用完成的，就是 &e，e的变化会导致实参的变化
    39. }
    40. //模拟便道的队列的性质；
    41. typedef struct duilie {//队列就是便道（候车区）
    42. 	int number; //汽车车号
    43. 	float ar_time; //汽车到达时间
    44. 	struct duilie* next;//链式的队列结点，通过next指针访问相邻的队列结点
    45. }*queueptr;//指向队列结点自身的指针
    46. typedef struct {
    47. 	queueptr front; //便道的队列的对头
    48. 	queueptr rear; //便道的队列的队尾
    49. 	int length;//队列长度
    50. }linkqueue;
    51. //队列的基本操作；
    52. void initqueue(linkqueue& q) //构造一个空队列q,也是初始化
    53. {
    54. 	q.front = q.rear = (queueptr)malloc(sizeof(duilie));//给队列q动态分配空间
    55. 	if (!q.front || !q.rear)
    56. 		exit(0);          //如果队首指针和队尾指针为NULL，则存储分配失败
    57. 	q.front->next = NULL;//队首指针的下一个队列结点置为NULL，队列结点进队列只能从队尾进
    58. 	q.length = 0;//初始化队列长度为零
    59. }
    60.  
    61. void enqueue(linkqueue& q, int number, int ar_time)  //进队列，把车结点插入队列尾（属性为number，ar_time）
    62. {
    63. 	queueptr p;//创建队列指针p
    64. 	p = (queueptr)malloc(sizeof(duilie));//为p分配空间
    65. 	if (!p) exit(0);                     //为空则存储分配失败
    66. 	p->number = number;//让队列结点的车牌号等于插入进来的车牌号
    67. 	p->ar_time = ar_time;//同上，给时间赋值
    68. 	p->next = NULL;//保证只能从队尾进队列
    69. 	q.rear->next = p;//将p结点插入到队尾
    70. 	q.rear = p;//此时队尾指针rear指向插入进来的p结点，方便下一次从队尾插入车结点信息
    71. 	q.length++;//插入后队列长度加一
    72. }
    73. void popqueue(linkqueue& q, queueptr& w)      //删除q的队头元素 w（属性为number，ar_time）
    74. {
    75. 	queueptr p;//创建中间队列指针p
    76. 	if (q.length==0)//队首队尾指针相同则候车区无车
    77. 	{
    78. 		printf("停车场通道为空");
    79. 		return;
    80. 	}
    81. 	p = q.front->next;//p指针指向队列q中的队首位置
    82. 	w = p;//将队首元素赋值给w,即w代表删除的队首元素
    83. 	q.front->next = p->next;//删除队首元素
    84. 	q.length--;//删除后队列长度减一
    85. }
    86.  
    87.  
    88. float shijiancha(float x, float y) //求时间差的子程序,x是进入时间，y是离开时间
    89. {
    90. 	if (x > y) {
    91. 		printf("非法时间数据");
    92. 		return -1;
    93. 	}
    94. 	int shix, shiy, fenx, feny;
    95. 	float shijiancha;//返回值，待赋值
    96. 	shix = x;//shix为进入时间的整数部分
    97. 	shiy = y;//shiy为离开时间的整数部分
    98. 	fenx = (int)((x - shix) * 100);//fenx为进入时间的小数部分的100倍
    99. 	feny = (int)((y - shiy) * 100);//feny为离开时间的小数部分的100倍
    100. 	if (fenx > feny)
    101. 	{//如果fenx>feny，时间差就等于离开的整数减去进入的整数-1再加上60+feny-fenx,实际上feny-fenx是负数
    102. 		shijiancha = (shiy - shix - 1) + (float)(feny + 60 - fenx) / 100;
    103. 	}
    104. 	else//这个就是正常的了，整数部分减加上小数部分减即可
    105. 		shijiancha = (shiy - shix) + (float)(feny - fenx) / 100;
    106. 	return shijiancha;//返回值为时间差
    107. }
    108.  
    109.  
    110. void jinru(stackhead& st, linkqueue& q)        //对进入停车场的汽车的处理；
    111. {
    112. 	int number;//待使用的车牌号
    113. 	float time_a;//待使用的时间
    114. 	printf("请输入车牌号:");
    115. 	scanf("%d", &number);//
    116. 	printf("请输入您进车场的时间(比如说：8点半则输入8.30):"); scanf("%f", &time_a);
    117. 	if (st.stacksize_curren < 2)//停车场可以停2辆车，大于两辆车执行else的语句
    118. 	{
    119. 		zanInode e;//创建车结点
    120. 		e.number = number;//给车牌号赋值
    121. 		e.ar_time = time_a;//给车时间赋值
    122. 		push(st, e);//将赋值好的车结点入栈
    123. 		printf("请把你的车停在%d号车道\n\n", st.stacksize_curren);//提示车停在了哪个车道
    124. 	}
    125. 	else//如果执行这段代码，说明停车场以及停满2辆车
    126. 	{
    127. 		enqueue(q, number, time_a);//将车停入候车区，也就是便道
    128. 		printf("停车场已满，请把你的车停在便道的第%d个位置上\n", q.length);
    129. 	}
    130. }
    131.  
    132.  
    133. void likai(stackhead &st, stackhead &sl, linkqueue &q)       //对离开的汽车的处理；
    134. {                                     //st 堆栈为停车场，sl 堆栈为倒车场
    135. 	int number, flag = 1;                    //q 为便道队列
    136. 	float sh, time_d, arrivaltime, money1;
    137. 	printf("请输入您的车牌号:"); scanf("%d", &number);
    138. 	printf("请输入您出车场的时间(比如说：8点半则输入8.30):");  scanf("%f", &time_d);
    139. 	zanInode e, q_to_s;//e为要查找的车结点，q_to_s为后面将从便道进入停车场的车结点
    140. 	queueptr w;//队列指针，待使用
    141. 	while (flag)  //此时flag=1，死循环
    142. 	{
    143. 		pop(st, e);//取出栈顶结点
    144. 		push(sl, e);//将取出的栈顶结点放入倒车场
    145. 		if (e.number == number)//如果车牌号对应
    146. 		{
    147. 			flag = 0;//flag变为0，死循环结束
    148. 			arrivaltime = e.ar_time;//将该结点的进入时间赋值给arrivaltime
    149. 			sh = shijiancha(arrivaltime, time_d);//带入计算时间差的函数并将时间差赋值给sh
    150. 			money1 = (int)sh * 2 + (sh - (int)sh) * 100 / 30;//收费依据
    151. 		}
    152. 	}
    153. 	pop(sl, e);                    //把倒车场的第一辆车（要离开的）去掉；
    154. 	while (sl.stacksize_curren)   //把倒车场的车倒回停车场
    155. 	{
    156. 		pop(sl, e); //取出栈顶结点
    157. 		push(st, e);//将取出的栈顶结点放入倒车场
    158. 	}
    159. 	if (st.stacksize_curren < 2 && q.length != 0)   //停车场有空位，便道上的车开进入停车场
    160. 	{
    161. 		popqueue(q, w);//取出便道的第一个车并把其信息赋值给w指针
    162. 		q_to_s.ar_time = w->ar_time;//将该车信息赋值给q_to_s结点
    163. 		q_to_s.number = w->number;
    164. 		push(st, q_to_s);//入栈，即停车
    165. 		printf("车牌为%d 的车已从通道进入停车场, 所在的停车位为 %d:\n", q_to_s.number, st.stacksize_curren);
    166. 	}
    167. 	printf("\n 收据");
    168. 	printf("车牌号:%d\n", number);
    169. 	printf("++++++++++++++++++++++++++++++\n");
    170. 	printf("     进车场时间:%4.2f\n", arrivaltime);
    171. 	printf("     出车场时间:%4.2f\n", time_d);
    172. 	printf("     停留时间:%4.2f\n", sh);
    173. 	printf("     应付(元) %4.2f\n", money1);
    174. 	printf("++++++++++++++++++++++++++++++\n\n");
    175. }
    176.  
    177.  
    178. int main()
    179. {
    180. 	int m = 100;
    181. 	int choose;                 //进入或离开的标识；
    182. 	stackhead sting, slinshi;  //停车场和临时倒车场堆栈的定义；
    183. 	linkqueue line;          //队列的定义；
    184. 	initstack(sting);        //构造停车场堆栈sting
    185. 	initstack(slinshi);      //构造倒车场堆栈slinshi
    186. 	initqueue(line);         //构造便道队列line
    187. 	printf("\n      ******************停车场管理程序***************        ");
    188. 	printf("\n*===========================================================*");
    189. 	printf("\n*温馨提示：请车主在24:00之前来取车，给您带来的不便,敬请原谅!*");
    190. 	printf("\n* 1 *** 汽车进车场    2 *** 汽车出车场     3 *** 退出程序   *");
    191. 	printf("\n*===========================================================*\n");
    192. 	while (m)//m为100，可以重复操作100次
    193. 	{
    194. 		printf("          请输入您需要的服务的代号(1、2、3)，谢谢！\n");
    195. 		scanf("%d", &choose);//待选择的操作
    196. 		switch (choose)
    197. 		{
    198. 		case 1: jinru(sting, line); break;            //汽车进车场
    199. 		case 2: likai(sting, slinshi, line); break;    //汽车出车场
    200. 		case 3: exit(0);//退出
    201. 		}
    202. 		--m;//m递减
    203. 	}
    204. }

    c++版

    包含的功能

    1、停车功能

            如果停车场满，能够暂时存放到便道内

    2、开走车功能

            将指定车开走后自动计费，便道内的车自动停到停车场

    3、查看停车场停车情况功能

            可以查看停车场有无空位和停车信息。

    4、退出程序功能

    运行效果

    停车功能测试：

    离开停车场并自动计费测试：

    查看停车场状况功能测试：

    源码

    1. #define _CRT_SECURE_NO_WARNINGS//visual stduio添加对scanf的信任
    2. #include <stdio.h>
    3. #include <stdlib.h>
    4. #include <iostream>//C++IO流头文件
    5. using namespace std;//C++命名空间，配合IO流头文件可使用cin>>输入，cout<<输出
    6. #define MaxSize 5  //停车场最大停车位
    7. #define fee 2 //一小时的费用 
    8. #define L    10000//宏定义
    9. typedef int ElemType;//将整型int名字变为ElemType,下面再使用ElemType就是整型的意思
    10. ElemType tmpnum = 0;//车牌号
    11. ElemType tmptime = 0;//进入时间
    12. typedef struct {
    13.     ElemType car_num[MaxSize];//车牌号数组
    14.     ElemType car_time[MaxSize];//进入时间数组
    15.     int top;//数组下标
    16. }STACK;//栈，存放所有的车牌号和进入时间数组
    17. typedef struct qnode {//队列结点
    18.     ElemType car_num;//包含车牌号
    19.     ElemType car_time;//和进入时间
    20.     struct qnode* next;//指向自身的指针，用来当问相邻队列结点
    21. }QTYPT;//将qnode重命名为QTYPT
    22. typedef struct qptr {//队列
    23.     QTYPT* front;//队首指针
    24.     QTYPT* rear;//队尾指针
    25. }SQUEUE;//将qptr重命名为SQUEUE
    26. void InitStack(STACK* S) {//初始化栈S
    27.     S->top = -1;//数组下标初始化为-1
    28. }
    29.  
    30. int Full(STACK* S) {//栈满的情况
    31.     if (S->top == MaxSize - 1) {
    32.         printf("\n Stack is full! Push");//提示栈满
    33.         return 0;
    34.     }
    35.     return 1;
    36. }
    37. //入栈函数Push
    38. int Push(STACK* S, ElemType num, ElemType time) {
    39.     if (S->top == MaxSize - 1) {
    40.         printf("\n Stack is full! Push");//栈满提示，并退出
    41.         return 0;
    42.     }
    43.     S->top++;                      //栈不满时数组下标加一，此时为0
    44.     S->car_num[S->top] = num;      //栈车牌号数组的car_num[top]赋值为num
    45.     S->car_time[S->top] = time;    //同车牌号，这次是进入时间的赋值
    46.     return 1;                      //赋值成功则返回1
    47. }
    48.  
    49. int Empty(STACK* S) {//栈空的情况
    50.     return (S->top == -1 ? 1 : 0);//栈空返回1
    51. }
    52. //出栈函数Pop
    53. int Pop(STACK* S, ElemType* num, ElemType* time) {
    54.     if (Empty(S)) {//栈空无法出栈
    55.         puts("Stack is free Pop");
    56.         return 0;
    57.     }//栈不空时
    58.     *num = S->car_num[S->top]; //将栈顶的车牌号赋值给*num
    59.     *time = S->car_time[S->top];//赋值时间给*time
    60.     S->top--;//出栈后数组下标减一
    61.     return 1;
    62. }
    63. //初始化队列
    64. void InitQueue(SQUEUE* LQ) {
    65.     QTYPT* p = NULL;//创建队列结点指针
    66.     p = (QTYPT*)malloc(sizeof(QTYPT));//为p职责和你分配空间
    67.     p->next = NULL;//使p指针的next为空，相当于头结点
    68.     LQ->front = LQ->rear = p;//初始化队首和队尾指针指向头结点p，
    69. }
    70. //将队列结点入队
    71. int EnQueue(SQUEUE* LQ, ElemType num, ElemType time) {
    72.     QTYPT* s;//创建s指针
    73.     s = (QTYPT*)malloc(sizeof(QTYPT));//分配空间
    74.     s->car_num = num;//将车牌号赋值给p指向的车牌号
    75.     s->car_time = time;//赋值时间
    76.     s->next = LQ->rear->next;//将s结点插入到队尾的下一个位置
    77.     LQ->rear->next = s;//队尾指针的下一个位置指向s
    78.     LQ->rear = s;//队尾指针指向新插入的结点，这样时头插法，符合队列后进后出的特点
    79.     return 1;
    80. }
    81. //计算队列有多少结点
    82. int CountQueue(SQUEUE* LQ) {
    83.     int i = 1;
    84.     QTYPT* mfront = NULL;//创建该队列的新队首指针
    85.     QTYPT* mrear = NULL;//创建新队尾指针
    86.     mfront = LQ->front;//将队首指针赋值给新队首指针，记录作用
    87.     mrear = LQ->rear;//同上
    88.     while (!(LQ->front == LQ->rear)) {//当队首不等于队尾指针时，i++,统计的结点个数增加
    89.         i++;
    90.         LQ->front = LQ->front->next;//队首指向队首的下一个位置
    91.     }
    92.     LQ->front = mfront;//统计完成后将队首指针指向原来的地址
    93.     return i;//i为结点个数
    94. }
    95.  
    96. int Empty_Q(SQUEUE* LQ) {//队列为空
    97.     return (LQ->front == LQ->rear ? 1 : 0);
    98. }
    99.  
    100. int OutQueue(SQUEUE* LQ, ElemType* num, ElemType* time) {//取队首
    101.     QTYPT* p;//创建对列结点指针
    102.     if (Empty_Q(LQ)) {//队列空不能取队首
    103.         puts("Quenue is free OutQuenue");
    104.         return 0;
    105.     }
    106.     p = LQ->front->next;//p指向队首结点
    107.     *num = p->car_num;//将队首结点信息赋值
    108.     *time = p->car_time;
    109.     LQ->front->next = p->next;//删除队首结点
    110.     if (LQ->front->next == NULL)//如果队首结点不存在
    111.         LQ->rear = LQ->front;//队首队尾指针相同，队空
    112.     free(p);//释放p结点
    113.     return 1;
    114. }
    115. //检查有无重复车牌号
    116. int chackinput(STACK* S, int pnum) {
    117.     int i = 0;
    118.     int num;
    119.     num = pnum;//将车牌号赋值
    120.     i = S->top;//i为栈顶位置的数组下标
    121.     for (; !(i == -1); i--)//从高到底遍历car_num数组，找到车牌号返回1，否则返回0
    122.         if (S->car_num[i] == num)
    123.             return 1;
    124.     return 0;
    125. }
    126. //检查时间输入是否合理
    127. int chacktime(STACK* S, int ptime) {
    128.     return S->car_time[S->top] <= ptime ? 1 : 0;//只有离开时间大于进入时间才能赋值成功
    129. }
    130. //显示停车场内状况
    131. int displaystats(STACK* S, int pinput) {
    132.     void displayhead();//显示菜单
    133.     int i = 0;
    134.     i = S->top;//i为栈顶位置的数组下标
    135.     switch (pinput)//调用的时候自动填入10000
    136.     {
    137.     case 10000:
    138.         {
    139.         if (!Empty(S))//栈不空
    140.             for (; !(i == -1); i--)//遍历输出栈内停车信息
    141.                 printf("<===%d时%d号车停于%d车位===>\n", S->car_time[i], S->car_time[i], i + 1);
    142.         else
    143.             cout << "停车场为空";
    144.         printf("还有车%d个位\n", MaxSize - S->top - 1);//剩余车位等于最大停车位-当前数组下标再-1,因为数组是从0开始
    145.         break;
    146.         }
    147.     default:
    148.         {
    149.         return 1;
    150.         }
    151.     }
    152.     return 0;
    153. }
    154. //功能菜单
    155. void displayhead() {
    156.     cout << '\n' << "<===============CT停车场管理系统===================>" << endl;
    157.     cout << "<==操作说明:  *******  ==>" << endl;
    158.     cout << "<==1： 停车命令 *******  ==>" << endl;
    159.     cout << "<==2： 出车命令  ***  ==>" << endl;
    160.     cout << "<==0： 退出程序  ***  ==>" << endl;
    161.     cout << "<==3:  显示停车场内状况     " << endl;
    162.     cout << "<==============================================>" << endl;
    163. }
    164. //打印收费条
    165. void displayChange(STACK* S, ElemType pnum, int ptime) {
    166.     printf("   (单价 %d元/小时 )\n", fee);//fee在宏定义有，值为2
    167.     printf("<======================电子收据===================>\n");
    168.     printf("<==停车时间:--------------------------%d小时     ==>\n", ptime - tmptime);//停车时长
    169.     printf("<==车牌号码:--------------------------%d         ==>\n", tmpnum);//打印车牌号
    170.     printf("<==应收费用:--------------------------%d  元     ==>\n", (ptime - tmptime) * fee);//计算费用
    171.     printf("<====================谢谢=欢迎下次再来=============>\n");
    172.  
    173. }
    174. //开走车
    175. int outparkstation(STACK* S1, STACK* TS, ElemType pnum) {
    176.     int t_num = 0;
    177.     int t_time = 0;
    178.     while (1) {
    179.         Pop(S1, &t_num, &t_time);//取出栈顶车
    180.         if (t_num == pnum) {//如果这一次取出的栈顶车的车牌号是我们想开走的
    181.             tmpnum = t_num;//进行车牌号和进入时间的赋值
    182.             tmptime = t_time;
    183.             while (!Empty(TS)) {//当备用停车场不空时
    184.                 Pop(TS, &t_num, &t_time);//循环取出备用停车场的暂存栈顶车
    185.                 Push(S1, t_num, t_time);//将每次的栈顶车再放进停车场
    186.             }
    187.             return 1;//结束循环
    188.         }
    189.         Push(TS, t_num, t_time);//栈顶不是我们想要的车就暂存再备用停车场
    190.     }
    191.     return 0;
    192. }
    193. //进行停车
    194. int inparkstation(STACK* S) {
    195.     int parknum;
    196.     int parktime;
    197.     printf("还有%d个车位\n", MaxSize - S->top - 1);
    198.     printf("请输入车牌号码:");
    199.     cin >> parknum;//输入车牌号
    200.     while (chackinput(S, parknum)) {//调用检验函数，重复则重新输入车牌号
    201.         printf("车牌号码重复，请输入%d1或者其他", parknum);
    202.         cin >> parknum;//输入车牌号
    203.     }
    204.     printf("请输入停车时间:");
    205.     cin >> parktime;//输入停车时间
    206.     printf("%d号车于%d时停靠在%d位\n", parknum, parktime, S->top + 2);//下标加2是因为初始为-1，第一个车位于一号位，需要加2
    207.     Push(S, parknum, parktime);//将输入的车牌号与进入时间入栈，完成停车
    208.     return 1;
    209. }
    210. //在便道，栈满时将车暂存到便道内
    211. int inbiandao(SQUEUE* SQ, STACK* S) {
    212.     int parknum;
    213.     printf("对不起,停车场已满，请您到便道等待.停车场有空位时您将第");
    214.     printf("%d进入停车场\n", CountQueue(SQ));//调用CountQueue()函数，得到便道内的结点个数
    215.     printf("请输入车牌号码:");
    216.     cin >> parknum;
    217.     while (chackinput(S, parknum)) {//如果有重复车牌号则重新输入
    218.         printf("车牌号码重复，请输入其他车牌号");
    219.         cin >> parknum;
    220.     }
    221.     EnQueue(SQ, parknum, 0);//将车牌号为parknum的车放进便道，进便道时间默认为0
    222.     return 1;
    223. }
    224. //离开停车场
    225. int OutParkingStation(SQUEUE* biandao, STACK* car, STACK* tmp) {
    226.     int parknum = 0;
    227.     int parktime = 0;
    228.     int buf = 0;
    229.     if (!Empty(car)) {//栈不空的情况下
    230.         displaystats(car, 10000);//遍历查看停车场停车情况
    231.         printf("请输入您要调出的车牌号码:");
    232.         cin >> parknum;
    233.         while (!chackinput(car, parknum)) {
    234.             printf("没有您要的%d的车牌号码,请输入正确的车牌号码：", parknum);//没有检查到重新输入
    235.             cin >> parknum;
    236.         }
    237.         outparkstation(car, tmp, parknum);//将车牌号为parknum的车开走
    238.         printf("%d时%d号车进入停车场\n", tmptime, tmpnum);//上一行代码已经给开走的车进入时间和车牌号赋值，
    239.         printf("请输入现在的时间:");//开走时的时间
    240.         cin >> parktime;
    241.         while (!chacktime(car, parktime)) {//开走时间需要大于进入时间，否则重新输入
    242.             cout << "输入时间小于停车时间，请重新输入:";
    243.             cin >> parktime;
    244.         }
    245.         displayChange(car, parknum, parktime);//打印账单
    246.         if (biandao->front != biandao->rear)  
    247.         {
    248.             printf("%d号车位空开\n", car->top + 2);//提示开走的车占用的停车场位置空了
    249.             printf("%d时便道上的%d号汽车驶入%d号车位", parktime, biandao->front->next->car_num, car->top + 2);//提示便道队首元素进入停车场
    250.             OutQueue(biandao, &parknum, &buf);//将便道队首元素的车牌号赋值给parknum
    251.             Push(car, parknum, parktime);//将该车进入停车场栈顶，进入成功
    252.         }
    253.         return 2;
    254.     }
    255.     printf("停车场为空\n");//栈空则停车场为空
    256.     return 1;
    257. };
    258.  
    259. int main() {
    260.    int chance = 0;//用来选择操作
    261.     STACK car;//创建未分配空间的car栈
    262.     InitStack(&car);//初始化，包括分配内存空间
    263.     STACK tmp;//备用栈
    264.     InitStack(&tmp);//初始化
    265.     SQUEUE biandao;//创建队列
    266.     InitQueue(&biandao);//初始化
    267. loop://跳转语句，配和goto语句使用
    268.     while (1) {
    269.         displayhead();//展示菜单
    270.         cout << "=>:";
    271.         cin >> chance;//输入操作的选择
    272.         switch (chance) {
    273.         case 1:
    274.         {
    275.             printf("查询结果为：\n");
    276.             if (Full(&car))//栈未满时执行if，栈满时执行else
    277.                 inparkstation(&car);//停进停车场
    278.             else
    279.                 inbiandao(&biandao, &car);//停进便道
    280.             break;
    281.         }
    282.         case 2:
    283.         {
    284.             OutParkingStation(&biandao, &car, &tmp);//开走车
    285.             break;
    286.         }
    287.         case 3:
    288.         {
    289.             displaystats(&car, 10000);//查看停车场信息
    290.             break;
    291.         }
    292.         case 0:
    293.         {
    294.             printf("成功退出，欢迎下次使用！");
    295.             return 0;//退出循环
    296.         }
    297.         default:
    298.         {
    299.             cout << "输入错误" << endl;
    300.             goto loop;//goto语句是跳转的意思，跳转到前面的loop位置，即继续选择操作
    301.         }
    302.         }
    303.     }
    304.     system("PAUSE");//终端出现按任意键继续，终端就是显示运行结果的地方
    305.     return 0;
    306. }

    ✨写在后面

            爆肝万字的两个版本的停车场管理程序你爱了吗，反正我是累死了。在最后希望家人们给个三连支持哇，你们的鼓励是我创作的不竭动力！！！

  • 相关阅读:
    泛型初识~go1.18的新类型
    【MLOps】优化超参数
    Java中的ORM框架——myBatis
    go 这样做就是python
    极坐标系下的交换积分次序
    ASP.NET的WebService跨域CORS问题解决方案
    企业电子招投标采购系统源码之电子招投标的组成
    java反射
    cnn训练自己数据集
    Spring Boot + Vue的网上商城之客服系统实现
  • 原文地址：https://blog.csdn.net/m0_58618795/article/details/125516288