设计并实现一个停车场管理系统。 描述：设停车场是一个可停放 n 辆汽车的狭长通道，且只有一个大门可供汽车进出。汽 车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的 第一辆车停放在车场的最北端），若车场内已停满 n 辆汽车，则后来的汽车只能在门外的便 道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时， 在它之后进入的车辆必须先退出车场为它让路，待该车辆开出大门外，其他车辆再按照原次 序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。试 为停车场编制按上述要求进行管理的模拟程序。 以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟 管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码以及 到达或离去的时刻。对每一组输入数据进行操作后的输出信息为：若是车辆到达，则输出汽 车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应 交纳的费用（在便道上停留的时间不收费）。栈以顺序结构实现，队列以链表结构实现。用C语言编写

好的，以下是一个使用 C 语言实现的停车场管理系统的代码示例：

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

#define MAX_CAPACITY 10   // 停车场最大容量
#define WAITING_CAPACITY 5   // 便道最大容量
#define FEE_RATE 1.0   // 停车费用计费比率

// 定义车辆结构体
typedef struct {
    char plate_number[10];   // 车牌号码
    time_t arrival_time;   // 到达时间
} Car;

// 定义栈结构体
typedef struct {
    Car cars[MAX_CAPACITY];   // 存储车辆的数组
    int top;   // 栈顶指针
} ParkStack;

// 定义队列结构体
typedef struct Node {
    Car car;   // 存储车辆的结构体
    struct Node* next;   // 指向下一个节点的指针
} QueueNode;

typedef struct {
    QueueNode* front;   // 队头指针
    QueueNode* rear;   // 队尾指针
} ParkQueue;

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

// 判断栈是否为空
int isStackEmpty(ParkStack* stack) {
    return stack->top == -1;
}

// 判断栈是否已满
int isStackFull(ParkStack* stack) {
    return stack->top == MAX_CAPACITY - 1;
}

// 入栈
void pushStack(ParkStack* stack, Car car) {
    if (isStackFull(stack)) {
        printf("停车场已满，%s进入便道等待\n", car.plate_number);
        return;
    }
    stack->top++;
    stack->cars[stack->top] = car;
    printf("%s停在了第%d个位置\n", car.plate_number, stack->top + 1);
}

// 出栈
void popStack(ParkStack* stack, Car car) {
    int i, found = 0;
    time_t departure_time;
    double parking_time, fee;

    // 在停车场中查找指定车辆
    for (i = stack->top; i >= 0; i--) {
        if (strcmp(stack->cars[i].plate_number, car.plate_number) == 0) {
            found = 1;
            break;
        }
    }

    if (found) {
        departure_time = time(NULL);
        parking_time = difftime(departure_time, stack->cars[i].arrival_time);
        fee = parking_time * FEE_RATE;
        stack->top--;
        printf("%s停留了%.0f秒，停车费用为%.2f元\n", car.plate_number, parking_time, fee);
        // 将便道中的车辆入栈
        if (!isStackEmpty(stack)) {
            Car waiting_car = ((ParkQueue*)stack->cars[MAX_CAPACITY - 1].arrival_time)->front->car;
            pushStack(stack, waiting_car);
            ((ParkQueue*)stack->cars[MAX_CAPACITY - 1].arrival_time)->front = ((ParkQueue*)stack->cars[MAX_CAPACITY - 1].arrival_time)->front->next;
            free(((ParkQueue*)stack->cars[MAX_CAPACITY - 1].arrival_time)->front);
            ((ParkQueue*)stack->cars[MAX_CAPACITY - 1].arrival_time)->front = NULL;
        }
    } else {
        printf("停车场中没有找到%s\n", car.plate_number);
    }
}

// 初始化队列
void initQueue(ParkQueue* queue) {
    queue->front = NULL;
    queue->rear = NULL;
}

// 判断队列是否为空
int isQueueEmpty(ParkQueue* queue) {
    return queue->front == NULL;
}

// 判断队列是否已满
int isQueueFull(ParkQueue* queue) {
    int count = 0;
    QueueNode* p = queue->front;
    while (p != NULL) {
        count++;
        p = p->next;
    }
    return count == WAITING_CAPACITY;
}

// 入队
void enqueue(ParkQueue* queue, Car car) {
    if (isQueueFull(queue)) {
        printf("便道已满，%s无法进入停车场\n", car.plate_number);
        return;
    }
    QueueNode* new_node = (QueueNode*)malloc(sizeof(QueueNode));
    new_node->car = car;
    new_node->next = NULL;
    if (isQueueEmpty(queue)) {
        queue->front = new_node;
    } else {
        queue->rear->next = new_node;
    }
    queue->rear = new_node;
    printf("%s停在了便道上的第%d个位置\n", car.plate_number, WAITING_CAPACITY - isQueueFull(queue));
}

// 出队
Car dequeue(ParkQueue* queue) {
    if (isQueueEmpty(queue)) {
        printf("便道中没有车辆等待\n");
        exit(1);
    }
    QueueNode* front = queue->front;
    Car car = front->car;
    queue->front = front->next;
    free(front);
    front = NULL;
    return car;
}

int main() {
    ParkStack stack;
    ParkQueue queue;
    initStack(&stack);
    initQueue(&queue);

    while (1) {
        char command[10], plate_number[10];
        time_t time_now = time(NULL);
        struct tm* now = localtime(&time_now);
        int hour = now->tm_hour;
        int minute = now->tm_min;
        int second = now->tm_sec;
        printf("请输入指令：");
        scanf("%s", command);
        if (strcmp(command, "到达") == 0) {
            Car car;
            car.arrival_time = time(NULL);
            scanf("%s", car.plate_number);
            if (isStackFull(&stack)) {
                enqueue(&queue, car);
            } else {
                pushStack(&stack, car);
            }
        } else if (strcmp(command, "离开") == 0) {
            Car car;
            scanf("%s", car.plate_number);
            popStack(&stack, car);
        } else if (strcmp(command, "查询") == 0) {
            scanf("%s", plate_number);
            int i, found = 0;
            for (i = stack.top; i >= 0; i--) {
                if (strcmp(stack.cars[i].plate_number, plate_number) == 0) {
                    found = 1;
                    printf("%s在停车场中的位置为%d，已停留%.0f秒\n", plate_number, i + 1, difftime(time(NULL), stack.cars[i].arrival_time));
                    break;
                }
            }
            if (!found) {
                QueueNode* p = queue.front;
                int position = 1;
                while (p != NULL) {
                    if (strcmp(p->car.plate_number, plate_number) == 0) {
                        printf("%s在便道上的位置为%d，还需等待%d辆车\n", plate_number, position, WAITING_CAPACITY - isQueueFull(&queue) - position + 1);
                        break;
                    }
                    position++;
                    p = p->next;
                }
                if (p == NULL) {
                    printf("未找到%s\n", plate_number);
                }
            }
        } else if (strcmp(command, "退出") == 0) {
            break;
        } else {
            printf("无效指令\n");
        }
    }

    return 0;
}

以上代码仅供参考，可能还存在一些问题和不足之处，需要根据实际情况进行调试和修改。