停车场管理程序设计

 停车场管理系统 - 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)
    {