C语言栈和队列实现停车场管理系统

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

#define MAX_SIZE 10 // 停车场最大容量
#define MAX_WAITING_QUEUE_SIZE 5 // 便道最大容量

typedef struct {
    char license[10]; // 车牌号
    int arrival_time; // 到达时间
} Car;

typedef struct {
    Car cars[MAX_SIZE]; // 车辆数组
    int top; // 栈顶指针
} ParkingLot;

typedef struct {
    Car cars[MAX_WAITING_QUEUE_SIZE]; // 车辆数组
    int front; // 队头指针
    int rear; // 队尾指针
} WaitingQueue;

// 初始化停车场
void init_parking_lot(ParkingLot *parking_lot) {
    parking_lot->top = -1;
}

// 判断停车场是否为空
int is_parking_lot_empty(ParkingLot *parking_lot) {
    return parking_lot->top == -1;
}

// 判断停车场是否已满
int is_parking_lot_full(ParkingLot *parking_lot) {
    return parking_lot->top == MAX_SIZE - 1;
}

// 车辆进入停车场
void push_car_to_parking_lot(ParkingLot *parking_lot, Car car) {
    if (is_parking_lot_full(parking_lot)) {
        printf('停车场已满，无法停车\n');
        return;
    }
    parking_lot->top++;
    parking_lot->cars[parking_lot->top] = car;
    printf('车辆 %s 已停入停车场\n', car.license);
}

// 车辆离开停车场
Car pop_car_from_parking_lot(ParkingLot *parking_lot) {
    if (is_parking_lot_empty(parking_lot)) {
        printf('停车场已空，无法取车\n');
        Car empty_car = {'', 0};
        return empty_car;
    }
    Car car = parking_lot->cars[parking_lot->top];
    parking_lot->top--;
    printf('车辆 %s 已从停车场取出\n', car.license);
    return car;
}

// 初始化便道
void init_waiting_queue(WaitingQueue *waiting_queue) {
    waiting_queue->front = waiting_queue->rear = 0;
}

// 判断便道是否为空
int is_waiting_queue_empty(WaitingQueue *waiting_queue) {
    return waiting_queue->front == waiting_queue->rear;
}

// 判断便道是否已满
int is_waiting_queue_full(WaitingQueue *waiting_queue) {
    return (waiting_queue->rear + 1) % MAX_WAITING_QUEUE_SIZE == waiting_queue->front;
}

// 车辆进入便道
void enqueue_car_to_waiting_queue(WaitingQueue *waiting_queue, Car car) {
    if (is_waiting_queue_full(waiting_queue)) {
        printf('便道已满，无法停车\n');
        return;
    }
    waiting_queue->rear = (waiting_queue->rear + 1) % MAX_WAITING_QUEUE_SIZE;
    waiting_queue->cars[waiting_queue->rear] = car;
    printf('车辆 %s 已停入便道\n', car.license);
}

// 车辆离开便道
Car dequeue_car_from_waiting_queue(WaitingQueue *waiting_queue) {
    if (is_waiting_queue_empty(waiting_queue)) {
        printf('便道已空，无车可取\n');
        Car empty_car = {'', 0};
        return empty_car;
    }
    waiting_queue->front = (waiting_queue->front + 1) % MAX_WAITING_QUEUE_SIZE;
    Car car = waiting_queue->cars[waiting_queue->front];
    printf('车辆 %s 已从便道取出\n', car.license);
    return car;
}

// 显示停车场车辆
void display_parking_lot(ParkingLot *parking_lot) {
    printf('停车场车辆：\n');
    if (is_parking_lot_empty(parking_lot)) {
        printf('停车场为空\n');
        return;
    }
    for (int i = parking_lot->top; i >= 0; i--) {
        printf('%s\n', parking_lot->cars[i].license);
    }
}

// 显示便道上车辆
void display_waiting_queue(WaitingQueue *waiting_queue) {
    printf('便道上车辆：\n');
    if (is_waiting_queue_empty(waiting_queue)) {
        printf('便道为空\n');
        return;
    }
    for (int i = (waiting_queue->front + 1) % MAX_WAITING_QUEUE_SIZE; i != (waiting_queue->rear + 1) % MAX_WAITING_QUEUE_SIZE; i = (i + 1) % MAX_WAITING_QUEUE_SIZE) {
        printf('%s\n', waiting_queue->cars[i].license);
    }
}

// 显示系统菜单
void display_menu() {
    printf('停车场管理系统\n');
    printf('1. 车辆到达\n');
    printf('2. 车辆离开\n');
    printf('3. 显示停车场车辆\n');
    printf('4. 显示便道上车辆\n');
    printf('0. 退出\n');
}

int main() {
    ParkingLot parking_lot;
    WaitingQueue waiting_queue;
    init_parking_lot(&parking_lot);
    init_waiting_queue(&waiting_queue);
    int choice;
    do {
        display_menu();
        printf('请选择功能：');
        scanf('%d', &choice);
        switch (choice) {
            case 1: {
                printf('请输入车牌号和到达时间（以空格分隔）：');
                Car car;
                scanf('%s %d', car.license, &car.arrival_time);
                push_car_to_parking_lot(&parking_lot, car);
                break;
            }
            case 2: {
                printf('请输入车牌号：');
                char license[10];
                scanf('%s', license);
                Car car_to_leave;
                int found = 0;
                // 将停车场内的车辆取出，找到目标车辆后停止
                while (!is_parking_lot_empty(&parking_lot)) {
                    Car car = pop_car_from_parking_lot(&parking_lot);
                    if (strcmp(car.license, license) == 0) {
                        found = 1;
                        car_to_leave = car;
                        break;
                    } else {
                        enqueue_car_to_waiting_queue(&waiting_queue, car);
                    }
                }
                // 将便道上的车辆重新停回停车场
                while (!is_waiting_queue_empty(&waiting_queue)) {
                    Car car = dequeue_car_from_waiting_queue(&waiting_queue);
                    push_car_to_parking_lot(&parking_lot, car);
                }
                if (found) {
                    printf('车辆 %s 已离开\n', car_to_leave.license);
                } else {
                    printf('未找到车辆 %s\n', license);
                }
                break;
            }
            case 3:
                display_parking_lot(&parking_lot);
                break;
            case 4:
                display_waiting_queue(&waiting_queue);
                break;
            case 0:
                printf('谢谢使用\n');
                break;
            default:
                printf('无效选择，请重新选择\n');
        }
    } while (choice != 0);
    return 0;
}