停车场管理程序设计

the_memory520

于 2023-12-26 14:26:57 发布

阅读量1.4k

点赞数 22

文章标签：数据结构

本文链接：https://blog.csdn.net/the_memory/article/details/135218310

版权

停车场管理系统 - C语言实现

简介
本文介绍了一个简单的停车场管理系统的C语言实现。该系统允许用户将车辆添加到停车场、从停车场移除车辆，查看停车场内外的车辆情况，以及对停车时长进行计算和收费等功能。

一、代码结构
1、结构体
- `Car`：车辆信息结构体，包括车牌号、车主信息、位置、到达时间和收费金额等属性。
- `Stack`：栈结构，用于实现停车场。
- `CQueueNode`：队列节点结构，用于实现停车场外便道。
- `LinkQueue`：队列结构，用于管理停车场外便道上的车辆。

2、主要函数
- `InitStack`：初始化栈。
- `Push`：将车辆入栈。
- `IsEmpty`：判断栈是否为空。
- `IsFull`：判断栈是否已满。
- `In`：车辆到达停车场。
- `Out`：车辆离开停车场。
- `saveDates`：将停车场数据保存到磁盘文件。
- `readDates`：从磁盘文件读取停车场数据。

3、控制流程
`control` 函数实现了停车场管理系统的各项功能，包括车辆到达、离开、查看停车场情况、数据持久化等。

4、数据持久化
本系统实现了数据持久化功能，可以将停车场数据保存到磁盘文件，并在需要时从磁盘文件读取数据。

二、结论
停车场管理系统的实现对于学习C语言和数据结构非常重要。通过本文介绍的系统，读者可以了解如何使用C语言实现简单的数据结构和算法，并了解数据持久化的实现方法。

三、实现代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>

#define SIZE 3 //停车场容量

typedef struct
{
char num[6]; // 车牌号
char owner[20]; // 车主信息
int position; // 位置
int arrivalTime; // 到达时间（以分钟为单位）
float money; // 收费金额
} Car;

typedef struct
{
Car elem[SIZE + 1];
int top;
} Stack;

typedef struct Node
{
Car data;
struct Node* next;
} CQueueNode;

typedef struct
{
CQueueNode* front;
CQueueNode* rear;
} LinkQueue;

void control();
void InitStack(Stack* S);
void Push(Stack* S, Car* r);
int IsEmpty(Stack* S);
int IsFull(Stack* S);
int GetTop(Stack* S, Car* n);
void InitQueue(LinkQueue* Q);
int EnterQueue(LinkQueue* Q, Car* t);
int DeleteQueue(LinkQueue* Q, Car* x);
void print1(Stack* S);
void print2(LinkQueue* Q);
void TaM(Car* r, int arrivalTime);
void In(Stack* S, LinkQueue* Q, Car* r);
void Out(Stack* S, Stack* S0, Car* r, LinkQueue* Q);
void print();
int saveDates(Stack* S);
int readDates(Stack* S);
void SortByParkingTime(Car* cars, int size);
void printSortedParkingData(Car* cars, int size);
int FindCarByNum(Stack* S, const char* num, Car* result);
void SortByCarNum(Car* cars, int size);
void printSortedCarData(Car* cars, int size);
void CalculateParkingDuration(Car* cars, int size, int arrivalTime);
int isLegalLicensePlateNumber(char* licensePlateNumber);

int main()
{
control();
return 0;
}

void InitStack(Stack* S)
{
S->top = 0;
}

void Push(Stack* S, Car* r)
{
S->top++;
strcpy(S->elem[S->top].num, r->num);
strcpy(S->elem[S->top].owner, r->owner);
r->position = S->elem[S->top].position = S->top;
S->elem[S->top].arrivalTime = r->arrivalTime;
}

int IsEmpty(Stack* S)
{
return (S->top == 0 ? 1 : 0);
}

int IsFull(Stack* S)
{
return (S->top == SIZE ? 1 : 0);
}

int GetTop(Stack* S, Car* n)
{
strcpy(n->num, S->elem[S->top].num);
strcpy(n->owner, S->elem[S->top].owner);
n->position = S->elem[S->top].position;
n->arrivalTime = S->elem[S->top].arrivalTime;
return 1;
}

void InitQueue(LinkQueue* Q)
{
Q->front = (CQueueNode*)malloc(sizeof(CQueueNode));
if (Q->front != NULL)
{
Q->rear = Q->front;
Q->front->next = NULL;
}
}

int EnterQueue(LinkQueue* Q, Car* t)
{
CQueueNode* NewNode;
NewNode = (CQueueNode*)malloc(sizeof(CQueueNode));
if (NewNode != NULL)
{
strcpy(NewNode->data.num, t->num);
strcpy(NewNode->data.owner, t->owner);
NewNode->data.arrivalTime = t->arrivalTime;
NewNode->next = NULL;
Q->rear->next = NewNode;
Q->rear = NewNode;
return 1;
}
else
{
return 0;
}
}

int DeleteQueue(LinkQueue* Q, Car* x)
{
CQueueNode* p;
if (Q->front == Q->rear)
{
return 0;
}
p = Q->front->next;
Q->front->next = p->next;
if (Q->rear == p)
{
Q->rear = Q->front;
}
strcpy(x->num, p->data.num);
strcpy(x->owner, p->data.owner);
x->arrivalTime = p->data.arrivalTime;
free(p);
return 1;
}

void print1(Stack* S)
{
int tag;
Car x;
printf("=========================================================================\n");
printf("停车场停车情况:\n");
if (IsEmpty(S))
{
printf("无车！");
}
printf("\t车牌号\t\t 车主信息\t\t停放位序\t到达时间\n");
for (tag = S->top; S->top > 0; S->top--)
{
if (GetTop(S, &x))
{
printf("\t %s \t\t %s \t\t %d\t\t %d\n", x.num, x.owner, x.position, x.arrivalTime);
}
}
printf("=========================================================================\n");
S->top = tag;
}

void print2(LinkQueue* Q)
{
printf("停车场外便道中等待车辆情况：\n");
CQueueNode* p;
p = Q->front->next;
printf("=========================================================================\n");
printf("\t等待车牌号\t\t车主信息\t\t到达时间\n");
for (; p != NULL; p = p->next)
{
printf("\t %s \t\t %s \t\t %d\n", p->data.num, p->data.owner, p->data.arrivalTime);
}
printf("=========================================================================\n");
}

void TaM(Car* r, int arrivalTime)
{
time_t currentTime;
struct tm* localTime;
time(&currentTime);
localTime = localtime(&currentTime);
int currentMinutes = localTime->tm_hour * 60 + localTime->tm_min;
int parkingMinutes = currentMinutes - arrivalTime;
printf("\n停车时长：%d分钟\n", parkingMinutes);
printf("每小时收费3元\n");
r->money = 0.05 * parkingMinutes;
printf("请支付金额%.2f元\n", r->money);
}

void In(Stack* S, LinkQueue* Q, Car* r)
{
if (IsFull(S))
{
printf("车库已满，请等待！\n");
EnterQueue(Q, r);
}
else
{
time_t currentTime;
struct tm* localTime;
time(&currentTime);
localTime = localtime(&currentTime);
int arrivalTime = localTime->tm_hour * 60 + localTime->tm_min;
r->arrivalTime = arrivalTime;
Push(S, r);
printf("\n您现在所在位置 %d\n", r->position);
}
}

void Out(Stack* S, Stack* S0, Car* r, LinkQueue* Q)
{
int tag = S->top;
Car x;
if (IsEmpty(S))
{
printf("没有此车！\n");
}
else
{
for (; strcmp(r->num, S->elem[tag].num) != 0 && tag > 0; --tag)
{
Push(S0, &S->elem[tag]);
S->top--;
}
if (strcmp(r->num, S->elem[tag].num) == 0)
{
TaM(r, S->elem[tag].arrivalTime);
S->top--;
for (; S0->top > 0; S0->top--)
{
Push(S, &S0->elem[S0->top]);
}
if (S->top < SIZE&& Q->front != Q->rear)
{
DeleteQueue(Q, &x);
Push(S, &x);
}
}
else if (tag == 0)
{
printf("未进入停车场应支付金额 0元！");
for (; S0->top > 0; S0->top--)
{
Push(S, &S0->elem[S0->top]);
}
}
}
printf("=========================================================================\n");
}

void CalculateParkingDuration(Car* cars, int size, int arrivalTime)
{
printf("=========================================================================\n");
printf("停车时长情况:\n");
printf("\t\t车辆\t\t停车时长\t\t此时所需支付停车费\n");
for (int i = 1; i <= size; i++)
{
int parkingMinutes = arrivalTime - cars[i].arrivalTime;
cars[i].money = 0.05 * parkingMinutes;
printf("\t\t %s \t\t %d 分钟 \t\t %.2f \n", cars[i].num, parkingMinutes, cars[i].money);
}
printf("=========================================================================\n");
}

void SortByParkingTime(Car* cars, int size)
{
int i, j;
Car temp;
for (i = 1; i <= size - 1; ++i)
{
for (j = 1; j <= size - i; ++j)
{
if (cars[j].arrivalTime > cars[j + 1].arrivalTime)
{
temp = cars[j];
cars[j] = cars[j + 1];
cars[j + 1] = temp;
}
}
}
}

void printSortedParkingData(Car* cars, int size)
{
printf("Sorted parking data based on parking time:\n");
for (int i = 1; i <= size; i++)
{
printf("车牌号 %s: 到达时间 %d\n", cars[i].num, cars[i].arrivalTime);
}
}

void SortByCarNum(Car* cars, int size)
{
int i, j;
Car temp;
for (i = 1; i <= size - 1; ++i)
{
for (j = 1; j <= size - i; ++j)
{
if (strcmp(cars[j].num, cars[j + 1].num) > 0)
{
temp = cars[j];
cars[j] = cars[j + 1];
cars[j + 1] = temp;
}
}
}
}

void printSortedCarData(Car* cars, int size)
{
printf("Sorted car data based on car number:\n");
for (int i = 1; i <= size; i++)
{
printf("车牌号 %s: 到达时间 %d\n", cars[i].num, cars[i].arrivalTime);
}
}

int FindCarByNum(Stack* S, const char* num, Car* result)
{
for (int i = S->top; i > 0; i--)
{
if (strcmp(S->elem[i].num, num) == 0)
{
strcpy(result->num, S->elem[i].num);
result->position = S->elem[i].position;
result->arrivalTime = S->elem[i].arrivalTime;
return 1; // 找到并返回
}
}
return 0; // 未找到
}

int isLegalLicensePlateNumber(char* licensePlateNumber)
{
if (strlen(licensePlateNumber) == 5)
{
for (int i = 0; i < 5; i++)
{
if (!isalpha(licensePlateNumber[i]) && !isdigit(licensePlateNumber[i]))
{
return 0; // 非法车牌号
}
}
return 1; // 合法车牌号
}
else
{
return 0; // 非法车牌号
}
}

int saveDates(Stack* S)
{
FILE* fp = fopen("theParking.bin", "wb");
if (fp == NULL)
{
printf("File open failed!\n");
return 1;
}
fwrite(S, sizeof(Stack), 1, fp);
fclose(fp);
return 0;
}

int readDates(Stack* S)
{
FILE* fp = fopen("theParking.bin", "rb");
if (fp == NULL)
{
printf("File open failed!\n");
return 1;
}
fread(S, sizeof(Stack), 1, fp);
int tag;
Car x;
printf("=========================================================================\n");
printf("停车场停车情况:\n");
printf("\t车牌号\t\t车主信息\t\t停放位序\t到达时间\n");
for (tag = S->top; S->top > 0; S->top--)
{
if (GetTop(S, &x))
{
printf("\t %s \t\t %s \t\t %d \t\t %d\n", x.num, x.owner, x.position, x.arrivalTime);
}
}
printf("=========================================================================\n");
S->top = tag;
fclose(fp);
return 0;
}

void print()
{
printf("\t\t==================================================================\n");
printf("\t\t***************************欢迎光临*******************************\n");
printf("\t\t******************************************************************\n");
printf("\t\t* 请选择: *\n");
printf("\t\t*-------------------0 :退出进程----------------------------------*\n");
printf("\t\t*-------------------1 :车辆到达停车场----------------------------*\n");
printf("\t\t*-------------------2 :车辆离开停车场----------------------------*\n");
printf("\t\t*-------------------3 :查看停车场内的车辆数据--------------------*\n");
printf("\t\t*-------------------4 :查看停车场外便道上的车辆数据--------------*\n");
printf("\t\t*-------------------5 :将Stack中的数据存入磁盘文件---------------*\n");
printf("\t\t*-------------------6 :将磁盘文件中的数据读取到Stack-------------*\n");
printf("\t\t*-------------------7 :将停车场中车辆按到达停车场时间排序--------*\n");
printf("\t\t*-------------------8 :将停车场中车辆按车牌号排序----------------*\n");
printf("\t\t*-------------------9 :根据车牌号查找车辆信息--------------------*\n");
printf("\t\t*-------------------10:计算所有车辆到达某一时间的停车时长--------*\n");
printf("\t\t******************************************************************\n");
printf("\t\t-----------------收费标准：每小时3元，每分钟0.05元----------------\n");
printf("\t\t==================================================================\n\n");
}

void control()
{
int sel = 1;
Car c[10] = { 0 };
int carCount = 0;
char carNumToFind[6] = { 0 };
Car foundCar;
Stack S, S0;
LinkQueue Q;

InitStack(&S);
InitStack(&S0);
InitQueue(&Q);

system("color 0E");
system("cls");

while (sel != 0)
{
print();
printf("Input your choice: ");
scanf("%d", &sel);
fflush(stdin);

switch (sel)
{
case 0:
return;
case 1:
if (carCount < 10)
{
char ch[6] = { 0 };
int n = 0;
printf("Enter car number: ");
scanf("%s", ch);
n = isLegalLicensePlateNumber(ch);
if (n == 0)
{
printf("Invalid license plate number!\n");
break;
}
else
{
printf("Valid license plate number!\n");
}
strcpy(c[carCount].num, ch);
printf("Enter owner information: ");
scanf("%s", c[carCount].owner);
printf("Car arrival time is recorded.\n");
In(&S, &Q, &c[carCount]);
carCount++;
}
else
{
printf("No available parking space!\n");
}
break;
case 2:
printf("Enter car number: ");
scanf("%s", carNumToFind);
fflush(stdin);
for (int i = 0; i < carCount; i++)
{
if (strcmp(carNumToFind, c[i].num) == 0)
{
Out(&S, &S0, &c[i], &Q);
break;
}
}
break;
case 3:
print1(&S);
break;
case 4:
print2(&Q);
break;
case 5:
saveDates(&S);
break;
case 6:
readDates(&S);
break;
case 7:
SortByParkingTime(c, carCount);
printSortedParkingData(c, carCount);
break;
case 8:
SortByCarNum(c, carCount);
printSortedCarData(c, carCount);
break;
case 9:
printf("Enter car number to find: ");
scanf("%s", carNumToFind);
if (isLegalLicensePlateNumber(carNumToFind))
{
if (FindCarByNum(&S, carNumToFind, &foundCar))
{
printf("Car information: Car number %s, parking position %d, arrival time %d\n",
foundCar.num, foundCar.position, foundCar.arrivalTime);
}
else
{
printf("Car with number %s not found\n", carNumToFind);
}
}
else
{
printf("Invalid license plate number!\n");
}
break;
case 10:
int arrivalTime;
printf("Enter the time to calculate parking duration (hour:minute): ");
scanf("%d", &arrivalTime);
CalculateParkingDuration(c, carCount, arrivalTime);
break;
default:
printf("Invalid input, please enter 1, 2, 3, 4, ..., 10\n");
}
}
}