数据结构停车场管理系统C语言

以下是一个简单的停车场管理系统的C语言代码，使用了栈和队列数据结构来实现车辆的进出管理：

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

#define MAX_SIZE 100 // 停车场最大容量

// 定义车辆结构体
typedef struct {
    char plate[10]; // 车牌号
    int time; // 进入时间
} Car;

// 定义栈结构体
typedef struct {
    Car data[MAX_SIZE]; // 数据
    int top; // 栈顶指针
} Stack;

// 定义队列结构体
typedef struct {
    Car data[MAX_SIZE]; // 数据
    int front, rear; // 队头和队尾指针
} Queue;

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

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

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

// 入栈
int push(Stack *s, Car c) {
    if (isFullStack(s)) {
        return 0;
    }
    s->data[++s->top] = c;
    return 1;
}

// 出栈
int pop(Stack *s, Car *c) {
    if (isEmptyStack(s)) {
        return 0;
    }
    *c = s->data[s->top--];
    return 1;
}

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

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

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

// 入队
int enQueue(Queue *q, Car c) {
    if (isFullQueue(q)) {
        return 0;
    }
    q->data[q->rear] = c;
    q->rear = (q->rear + 1) % MAX_SIZE;
    return 1;
}

// 出队
int deQueue(Queue *q, Car *c) {
    if (isEmptyQueue(q)) {
        return 0;
    }
    *c = q->data[q->front];
    q->front = (q->front + 1) % MAX_SIZE;
    return 1;
}

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("请选择操作：");
        scanf("%d", &choice);
        switch (choice) {
            case 1: {
                Car c;
                printf("请输入车牌号：");
                scanf("%s", c.plate);
                printf("请输入进入时间：");
                scanf("%d", &c.time);
                if (isFullStack(&s)) {
                    printf("停车场已满，车辆将进入便道队列\n");
                    if (!enQueue(&q, c)) {
                        printf("便道已满，无法停车\n");
                    }
                } else {
                    push(&s, c);
                    printf("车辆已停入停车场\n");
                }
                break;
            }
            case 2: {
                char plate[10];
                printf("请输入车牌号：");
                scanf("%s", plate);
                int flag = 0; // 标记是否找到车辆
                Stack tmp; // 临时栈
                initStack(&tmp);
                Car c;
                while (!isEmptyStack(&s)) {
                    pop(&s, &c);
                    if (strcmp(c.plate, plate) == 0) {
                        flag = 1;
                        printf("车辆已离开停车场，停车费用为：%d元\n", (c.time - time(NULL)) / 60);
                        break;
                    } else {
                        push(&tmp, c);
                    }
                }
                while (!isEmptyStack(&tmp)) {
                    pop(&tmp, &c);
                    push(&s, c);
                }
                if (!flag) {
                    printf("未找到该车辆\n");
                } else {
                    while (!isEmptyQueue(&q)) {
                        deQueue(&q, &c);
                        if (isFullStack(&s)) {
                            printf("停车场已满，便道车辆将无法进入\n");
                            if (!enQueue(&q, c)) {
                                printf("便道已满，车辆将无法停车\n");
                            }
                        } else {
                            push(&s, c);
                            printf("便道车辆已停入停车场\n");
                        }
                    }
                }
                break;
            }
            case 3: {
                printf("停车场：\n");
                Stack tmp; // 临时栈
                initStack(&tmp);
                Car c;
                while (!isEmptyStack(&s)) {
                    pop(&s, &c);
                    printf("%s %d\n", c.plate, c.time);
                    push(&tmp, c);
                }
                while (!isEmptyStack(&tmp)) {
                    pop(&tmp, &c);
                    push(&s, c);
                }
                printf("便道：\n");
                Queue tmp2; // 临时队列
                initQueue(&tmp2);
                while (!isEmptyQueue(&q)) {
                    deQueue(&q, &c);
                    printf("%s %d\n", c.plate, c.time);
                    enQueue(&tmp2, c);
                }
                while (!isEmptyQueue(&tmp2)) {
                    deQueue(&tmp2, &c);
                    enQueue(&q, c);
                }
                break;
            }
            case 4: {
                return 0;
            }
            default: {
                printf("输入有误，请重新输入\n");
                break;
            }
        }
    }
    return 0;
}