c语言以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入的输入数据序列进行

c语言以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行。

在这个模拟停车场的程序中，我们可以定义一个固定大小的停车场和便道，然后使用栈和队列来模拟停车场和便道的进出。首先，我们可以定义一个栈来表示停车场，栈的大小即停车场可以停放的车辆数量。然后，我们可以使用一个队列来表示车场外的便道，便道的长度即队列的大小。

当有车辆到达停车场时，我们首先判断停车场是否还有空位，如果有空位则将车辆压入停车场的栈中；如果停车场已经满了，则将车辆放到便道的队列中等待。当车辆需要离开停车场时，我们从栈中将车辆取出，并将便道上的车辆按照先后顺序依次压入停车场。

从终端读入的输入数据序列可以包括车辆的到达和离开信息，比如"arrive 123"表示车牌号为123的车辆到达停车场，"depart 123"表示车牌号为123的车辆离开停车场。根据输入数据序列的指令，我们可以模拟车辆在停车场和便道上的进出情况，并输出相应的结果。

通过这样的模拟，我们可以更加直观地理解栈和队列的概念，并且可以实际应用到停车场管理系统中，提高停车场的利用率和管理效率。

相关问题

设计并实现一个停车场管理系统。 描述：设停车场是一个可停放 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;
}

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

栈和队列停车场管理系统c语言代码

这个停车场管理系统是基于C语言数据结构中栈和队列思想的，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码、到达或离去的时刻。这个系统的基本要求是要求以顺序栈模拟停车场，以链队列模拟便道。具体的算法思想如下：
1.车辆停入停车场的流程：首先判断停车场的车位是否停满。两种情况：(1)停满时此时后来的车辆只能停在走道上 (2)未停满时后来的车辆继续入栈。
2.车辆出站的思想。两种情况：(1)车辆在栈顶时，此时直接出栈而用不到辅助栈(2)车辆不在车顶时排在前面的车辆必须让位，此时它才能出栈，算法思想是首先根据输入的车牌号进行在栈中搜索，返还一个角标，根据角标来，找到出栈的车辆，这时前面的车辆入辅助栈，当循环的目标车辆时，这时不需要入辅助栈，直接出栈即可！
总体结构思路如下：这时车位停满的情况，若非栈顶出栈则需要把他前面的车让位进辅助栈，当目标车出栈的再回来。
以下是一个简单的栈和队列停车场管理系统C语言代码的范例，仅供参考：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXSIZE 100
#define MAXCAR 20
#define PRICE 1
typedef struct{
    char num[10];
    int time;
}Car;
typedef struct{
    Car stack[MAXSIZE];
    int top;
}Stack;
typedef struct{
    Car queue[MAXSIZE];
    int front,rear;
}Queue;
Stack park;
Queue road;
void InitStack(Stack *s){
    s->top=-1;
}
int IsFull(Stack *s){
    if(s->top==MAXSIZE-1)
        return 1;
    else
        return 0;
}
int IsEmpty(Stack *s){
    if(s->top==-1)
        return 1;
    else
        return 0;
}
void Push(Stack *s,Car c){
    if(IsFull(s)){
        printf("停车场已满！\n");
        return;
    }
    s->top++;
    s->stack[s->top]=c;
}
Car Pop(Stack *s){
    Car temp;
    if(IsEmpty(s)){
        printf("停车场已空！\n");
        temp.num[0]='\0';
        temp.time=-1;
        return temp;
    }
    temp=s->stack[s->top];
    s->top--;
    return temp;
}
void InitQueue(Queue *q){
    q->front=q->rear=0;
}
int IsQueueFull(Queue *q){
    if((q->rear+1)%MAXSIZE==q->front)
        return 1;
    else
        return 0;
}
int IsQueueEmpty(Queue *q){
    if(q->front==q->rear)
        return 1;
    else
        return 0;
}
void InQueue(Queue *q,Car c){
    if(IsQueueFull(q)){
        printf("便道已满！\n");
        return;
    }
    q->queue[q->rear]=c;
    q->rear=(q->rear+1)%MAXSIZE;
}
Car OutQueue(Queue *q){
    Car temp;
    if(IsQueueEmpty(q)){
        printf("便道已空！\n");
        temp.num[0]='\0';
        temp.time=-1;
        return temp;
    }
    temp=q->queue[q->front];
    q->front=(q->front+1)%MAXSIZE;
    return temp;
}
void Arrive(){
    Car temp;
    printf("请输入车牌号和到达时间：\n");
    scanf("%s%d",temp.num,&temp.time);
    if(park.top<MAXCAR-1){
        Push(&park,temp);
        printf("停车成功！\n");
    }
    else{
        InQueue(&road,temp);
        printf("停车场已满，停在便道上！\n");
    }
}
void Leave(){
    Car temp;
    int time,cost,i,flag=0;
    printf("请输入车牌号和离开时间：\n");
    scanf("%s%d",temp.num,&time);
    while(!IsEmpty(&park)){
        temp=Pop(&park);
        if(strcmp(temp.num,num)==0){
            flag=1;
            cost=(time-temp.time)*PRICE;
            printf("停车时间为%d小时，应缴纳停车费%d元！\n",time-temp.time,cost);
            for(i=0;i<park.top;i++){
                Push(&park,Pop(&park));
            }
            return;
        }
        else{
            Push(&road,temp);
        }
    }
    if(flag==0){
        printf("未找到该车辆！\n");
        return;
    }
    while(!IsEmpty(&road)){
        Push(&park,OutQueue(&road));
    }
}
void List(){
    int i;
    if(IsEmpty(&park)){
        printf("停车场为空！\n");
        return;
    }
    printf("停车场：\n");
    for(i=park.top;i>=0;i--){
        printf("%s %d\n",park.stack[i].num,park.stack[i].time);
    }
    if(IsQueueEmpty(&road)){
        printf("便道为空！\n");
        return;
    }
    printf("便道：\n");
    for(i=road.front;i!=road.rear;i=(i+1)%MAXSIZE){
        printf("%s %d\n",road.queue[i].num,road.queue[i].time);
    }
}
int main(){
    int choice;
    InitStack(&park);
    InitQueue(&road);
    while(1){
        printf("停车场管理系统\n");
        printf("1.车辆到达\n");
        printf("2.车辆离开\n");
        printf("3.显示车辆信息\n");
        printf("4.退出系统\n");
        printf("请输入操作编号：\n");
        scanf("%d",&choice);
        switch(choice){
            case 1:Arrive();break;
            case 2:Leave();break;
            case 3:List();break;
            case 4:exit(0);
            default:printf("输入有误，请重新输入！\n");
        }
    }
    return 0;
}