C语言停车场管理系统：栈、队列实现及模块化设计

本项目使用C语言开发一个停车场管理系统，利用数据结构中的栈和队列，通过结构化程序设计方法进行模块化设计，实现车辆到达、离开、查询等功能。

系统设计

数据结构定义
- 使用结构体定义车辆信息，包含车牌号码、到达时间、停车时间等信息。
- 使用结构体定义栈和队列，分别使用数组存储数据，并使用指针管理栈顶和队头、队尾位置。
功能模块设计
- 车辆到达模块: 使用栈存储停车场中的车辆信息，当停车场满时，使用队列存储便道上的车辆信息。
- 车辆离开模块: 根据车牌号码从栈或队列中查找车辆，并进行相关处理。
- 显示停车场车辆: 遍历栈，显示停车场中所有车辆的信息。
- 显示便道上车辆: 遍历队列，显示便道上所有车辆的信息。
模块化实现
- 每个功能模块都封装成独立的函数，提高代码可读性和可维护性。

代码实现

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 100 // 定义栈和队列的最大容量

// 定义车辆结构体
typedef struct {
    char plateNum[10]; // 车牌号码
    int arrivalTime; // 到达时间
    int parkTime; // 停车时间
} Car;

// 定义栈结构体
typedef struct {
    Car data[MAXSIZE]; // 存储栈中元素的数组
    int top; // 栈顶指针
} Stack;

// 初始化栈
void initStack(Stack *s) {
    s->top = -1;
}

// 判断栈是否为空
int isEmptyStack(Stack *s) {
    return s->top == -1;
}

// 判断栈是否已满
int isFullStack(Stack *s) {
    return s->top == MAXSIZE - 1;
}

// 入栈
int pushStack(Stack *s, Car car) {
    if (isFullStack(s)) {
        return 0; // 栈已满，入栈失败
    }
    s->top++;
    s->data[s->top] = car;
    return 1; // 入栈成功
}

// 出栈
int popStack(Stack *s, Car *car) {
    if (isEmptyStack(s)) {
        return 0; // 栈为空，出栈失败
    }
    *car = s->data[s->top];
    s->top--;
    return 1; // 出栈成功
}

// 获取栈顶元素
int getTopStack(Stack *s, Car *car) {
    if (isEmptyStack(s)) {
        return 0; // 栈为空，获取栈顶元素失败
    }
    *car = s->data[s->top];
    return 1; // 获取栈顶元素成功
}

// 定义队列结构体
typedef struct {
    Car data[MAXSIZE]; // 存储队列中元素的数组
    int front; // 队头指针
    int rear; // 队尾指针
} Queue;

// 初始化队列
void initQueue(Queue *q) {
    q->front = 0;
    q->rear = 0;
}

// 判断队列是否为空
int isEmptyQueue(Queue *q) {
    return q->front == q->rear;
}

// 判断队列是否已满
int isFullQueue(Queue *q) {
    return (q->rear + 1) % MAXSIZE == q->front;
}

// 入队
int enqueue(Queue *q, Car car) {
    if (isFullQueue(q)) {
        return 0; // 队列已满，入队失败
    }
    q->data[q->rear] = car;
    q->rear = (q->rear + 1) % MAXSIZE;
    return 1; // 入队成功
}

// 出队
int dequeue(Queue *q, Car *car) {
    if (isEmptyQueue(q)) {
        return 0; // 队列为空，出队失败
    }
    *car = q->data[q->front];
    q->front = (q->front + 1) % MAXSIZE;
    return 1; // 出队成功
}

// 获取队头元素
int getFrontQueue(Queue *q, Car *car) {
    if (isEmptyQueue(q)) {
        return 0; // 队列为空，获取队头元素失败
    }
    *car = q->data[q->front];
    return 1; // 获取队头元素成功
}

// 车辆到达模块
void carArrival(Stack *s, Queue *q) {
    Car car;
    printf('请输入车牌号码：');
    scanf('%s', car.plateNum);
    printf('请输入到达时间：');
    scanf('%d', &car.arrivalTime);
    car.parkTime = 0;
    if (pushStack(s, car)) {
        printf('车辆已停入停车场。\n');
    } else if (enqueue(q, car)) {
        printf('停车场已满，车辆已停入便道。\n');
    } else {
        printf('停车场和便道均已满，车辆无法停入。\n');
    }
}

// 车辆离开模块
void carLeave(Stack *s, Queue *q) {
    char plateNum[10];
    printf('请输入要离开的车牌号码：');
    scanf('%s', plateNum);
    Car car;
    int flag = 0; // 标记车辆是否在停车场或便道上
    while (!isEmptyStack(s)) {
        getTopStack(s, &car);
        if (strcmp(car.plateNum, plateNum) == 0) {
            flag = 1;
            break;
        }
        popStack(s, &car);
    }
    if (flag) {
        printf('车辆已离开停车场，停车费用为%d元。\n', (car.parkTime - car.arrivalTime) * 2);
        while (!isEmptyStack(s)) {
            popStack(s, &car);
            car.parkTime++;
            if (!isEmptyQueue(q)) {
                dequeue(q, &car);
                pushStack(s, car);
                printf('便道上的车辆已停入停车场。\n');
            }
        }
    } else {
        flag = 0;
        while (!isEmptyQueue(q)) {
            dequeue(q, &car);
            if (strcmp(car.plateNum, plateNum) == 0) {
                flag = 1;
                break;
            }
            enqueue(q, car);
        }
        if (flag) {
            printf('车辆已离开便道。\n');
        } else {
            printf('未找到该车辆。\n');
        }
    }
}

// 显示停车场车辆
void displayParking(Stack *s) {
    printf('停车场车辆如下：\n');
    Stack temp;
    initStack(&temp);
    Car car;
    while (!isEmptyStack(s)) {
        popStack(s, &car);
        printf('车牌号码：%s，到达时间：%d，停车时间：%d\n', car.plateNum, car.arrivalTime, car.parkTime);
        pushStack(&temp, car);
    }
    while (!isEmptyStack(&temp)) {
        popStack(&temp, &car);
        pushStack(s, car);
    }
}

// 显示便道上车辆
void displayQueue(Queue *q) {
    printf('便道上车辆如下：\n');
    Queue temp;
    initQueue(&temp);
    Car car;
    while (!isEmptyQueue(q)) {
        dequeue(q, &car);
        printf('车牌号码：%s，到达时间：%d，停车时间：%d\n', car.plateNum, car.arrivalTime, car.parkTime);
        enqueue(&temp, car);
    }
    while (!isEmptyQueue(&temp)) {
        dequeue(&temp, &car);
        enqueue(q, car);
    }
}

// 主函数
int main() {
    Stack s;
    Queue q;
    initStack(&s);
    initQueue(&q);
    int choice;
    while (1) {
        printf('停车场管理系统\n');
        printf('1. 车辆到达\n');
        printf('2. 车辆离开\n');
        printf('3. 显示停车场车辆\n');
        printf('4. 显示便道上车辆\n');
        printf('5. 退出系统\n');
        printf('请选择功能：');
        scanf('%d', &choice);
        switch (choice) {
            case 1:
                carArrival(&s, &q);
                break;
            case 2:
                carLeave(&s, &q);
                break;
            case 3:
                displayParking(&s);
                break;
            case 4:
                displayQueue(&q);
                break;
            case 5:
                exit(0);
            default:
                printf('输入有误，请重新选择功能。\n');
                break;
        }
    }
    return 0;
}

总结

该项目通过合理的设计，实现了停车场管理系统的基本功能，并展示了栈和队列在实际应用中的运用。开发者可以通过对代码进行扩展，实现更多功能，例如停车费计算、车位分配等。