用栈和队列实现停车场

最新推荐文章于 2023-03-25 18:12:18 发布
最新推荐文章于 2023-03-25 18:12:18 发布
阅读量1.1k 收藏 9
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LX370ZZZ/article/details/81710741
版权

声明两个栈一个是停车栈一个是让路栈，当停车栈存满时，自动进入等候队列。当车进入停车场和离开停车场时都分别记录下时间，保存在栈和链表中，用链表去保存完整的信息。该项目有三个难点：1、出车时，也就是当车需要出去时需要通过让路栈实现出车。原理是要出中间某个元素就把这个元素之上的所有元素依次出栈并压入让路栈，然后保存一下时间并把他的所有信息保存到链表之中。最后把让路栈中的元素在出栈并压入原有栈中。此时需要检测是否栈中有空余，若有将等候队列中的车即队头元素删除并进停车栈； 2、时间函数，这个花了我好长时间最后采用了周围人提供的方法实现的； 3、需要注意当车进入登记时需检测车牌是否与队列与场内的车牌相同，相同需要提示出错，查询车辆信息时，要有顺序应该先查栈内信息在查队列，最后查询链表，当栈内查询到之后自动跳过队列的查询。代码如下：

头文件包括一些函数声明

#ifndef  _PARK_H
#define  _PARK_H

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

#define  success  10000
#define  failure  10001
#define  TRUE     10002
#define  FALSE    10003

#define BLACK                "\e[0;30m"
#define L_BLACK              "\e[1;30m"
#define RED                  "\e[0;31m"
#define L_RED                "\e[1;31m"
#define GREEN                "\e[0;32m"
#define L_GREEN              "\e[1;32m"
#define BROWN                "\e[0;33m"
#define YELLOW               "\e[1;33m"
#define BLUE                 "\e[0;34m"
#define L_BLUE               "\e[1;34m"
#define PURPLE               "\e[0;35m"
#define L_PURPLE             "\e[1;35m"
#define CYAN                 "\e[0;36m"
#define L_CYAN               "\e[1;36m"
#define GRAY                 "\e[0;37m"
#define WHITE                "\e[1;37m"
#define NONE                 "\e[0m"


struct information
{
    int no;
    char carnum[20];
    long t1;
    long t2;
    char intime[64];
    char outtime[64];
    long usetime;
    struct information *next;
};
typedef struct information Info;

struct parkinfo
{
    int no;
    char carnum[20];
    long t1;
    long t2;
    char outtime[64];
    char intime[64];
};
typedef struct parkinfo PInfo;

struct park
{
    int top;
    PInfo *pinfo;
};
typedef struct park Park;

struct node
{
    int no;
    char carnum[20];
    long t1;
    char intime[64];
    struct node *next;
};
typedef struct node Node;

struct wait
{
    Node *front;
    Node *rear;
};
typedef struct wait Wait;


int ParkInit(Park **p);
int WaitInit (Wait **p);
int InfoLinkInit(Info **p);
int Push(Park *p, PInfo *info);
int EmptyStack(Park *p);
int Pop(Park *p);
int StackClear(Park *s);
int StackDestroy(Park **p);
int QueueInsert(Wait *p, Node *info);
int DeleteQueue(Wait *p);
int QueueEmpty(Wait *q);
int ClearQueue(Wait *p);
int DestroyQueue(Wait **q);
int LinkInsert(Info *q, Info *e);
int LinkLength(Info *l);
int LinkEmpty(Info *q);
int ClearLink(Info *q);
int DestroyLink(Info **q);
int EnterCar(Park *park, Wait *wait);

#endif

这是main.c

#include "park.h"
int count = 1;
void Hello()
{
    printf("************************************************\n");
    printf("*****              菜   单                 *****\n");
    printf("************************************************\n");
    printf("*****         1、进车登记                  *****\n");
    printf("*****         2、出车登记                  *****\n");
    printf("*****         3、查询车辆信息              *****\n");
    printf("*****         4、查询出入记录              *****\n");
    printf("*****         5、查询场内车辆信息          *****\n");
    printf("*****         6、查询等候车辆信息          *****\n");
    printf("*****         7、退出系统                  *****\n");
    printf("************************************************\n");
}

int EnterCar(Park *park, Wait *wait)
{
    system("clear");
    char num[20];
    printf("请填写车辆信息(车牌号)\n");
    scanf("%s", num);
    int i;
    for(i = 0; i <= park->top; i++)
    {
        if(strcmp(num, park->pinfo[i].carnum) == 0)
        {
            printf("您输入的车牌已存在，如有疑惑请拨打 110！\n");
            sleep(1);
            return 0;
        }
    }
    Node *n = wait->front->next;
    while(n)
    {
        if(strcmp(num, n->carnum) == 0)
        {
            printf("您输入的车牌已存在，如有疑惑请拨打 110\n");
            return 0;
        }
        n = n->next;
    }

    printf("正在为您查询空闲车位.....\n");
    sleep(1);
    char flag = '*';
    char quit = 'a';
    while (flag == '*')
    {
        if(park->top == 9)
        {
            printf("停车位已满，请移至等候队列，注意礼让！\n");
            printf("如需退出本停车场，请按0,任意键继续！\n");
            scanf(" %c", &quit);
            if(quit == '0')
            {
                return;
            }
            Node *node = (Node *)malloc(sizeof(Node));
            strcpy(node->carnum, num);
            time_t t;
            t = time(NULL);
            node->t1 = time(&t);
            strcpy (node->intime, ctime(&t));
            node->no = count;
            count++;
            node->next = NULL;
            QueueInsert(wait, node);
            printf("车牌为%s 的车辆已进入等候队列！\n",node->carnum);
        }
        else
        {
            printf("您好！第%d个车位空闲\n",park->top + 2);
            printf("如需退出本停车场，请按0,任意键继续！\n");
            scanf(" %c", &quit);
            if(quit == '0')
            {
                return;
            }
            PInfo *pinfo = (PInfo *)malloc(sizeof(PInfo));
            strcpy(pinfo->carnum, num);
            time_t t;
            t = time(NULL);
            pinfo->t1 = time(&t);
            strcpy (pinfo->intime, ctime(&t));
            pinfo->no = count;
            count++;
            Push(park, pinfo);
            free(pinfo);
            printf("车牌为%s 的车辆已成功停靠！\n",park->pinfo[park->top].carnum);
            sleep(1);
        }
        printf("输入任意键返回！\n");
        scanf(" %c",&flag);
    }
    return success;
}

int OutCar(Park *park, Wait *wait, Info *info, Park *let)
{
    system("clear");
    char num[20];
    char quit = 'a';
    int i, j, top1 = park->top;
    char flag = '*';
    while(flag == '*')
    {
        printf("请登记需要驶出的车牌号！\n");
        scanf("%s", &num);
        printf("如需返回请按0，任意键继续！\n");
        scanf(" %c", &quit);
        if(quit == '0')
        {
            return;
        }
        for(i = 0; i <= top1; i++)
        {
            if(strcmp(park->pinfo[i].carnum, num) == 0)
            {
                break;
            }
        }
        if(i <= top1)
        {
            PInfo *pinfo = (PInfo *)malloc(sizeof(PInfo));
            for(j = 0; j < top1 - i; j++)
            {
                *pinfo = park->pinfo[park->top];
                Push(let, pinfo);
                Pop(park);
            }
            /*把栈里的信息转到链表中*/
            *pinfo = park->pinfo[park->top];
            time_t t;
            t = time(NULL);
            pinfo->t2 = time(&t);
            strcpy(pinfo->outtime, ctime(&t));
            Pop(park);
            Info *in = (Info *)malloc(sizeof(Info));
            in->no = pinfo->no;
            in->t1 = pinfo->t1;
            in->t2 = pinfo->t2;
            strcpy(in->carnum, pinfo->carnum);
            strcpy(in->intime, pinfo->intime);
            strcpy(in->outtime, pinfo->outtime);
            in->usetime = in->t2 - in->t1;
            LinkInsert(info, in);
            for(j = 0; j < top1 - i; j++)
            {
                *pinfo = let->pinfo[let->top];
                Push(park, pinfo);
                Pop(let);
            }
            free(pinfo);
            printf("已离开\n");
            sleep(1);
            PInfo *p2 = (PInfo *)malloc(sizeof(PInfo));
            int ret = QueueEmpty(wait);
            if(ret != TRUE)
            {
                printf("等候队列车牌号为%s 的车辆驶入!\n",wait->front->next->carnum);
                sleep(1);
                p2->no = wait->front->next->no;
                strcpy(p2->carnum, wait->front->next->carnum);
                time_t t2;
                t2 = time(NULL);
                p2->t1 = time(&t2);
                strcpy(p2->intime, ctime(&t2));
                Push(park, p2);
                free(p2);
                DeleteQueue(wait);
            }
        }
        else
        {
            printf("没有这辆车!\n");
        }
        printf("按任意键退出！\n");
        scanf(" %c", &flag);
    }
    return 0;
}

int QueryCar(Park *park, Wait *wait, Info * info)
{
    char quit = 'a';
    system("clear");
    printf("欢迎进入车辆信息查询系统,如需退出请按0，任意键继续\n");
    scanf(" %c", &quit);
    if(quit == '0')
    {
        return 0;
    }
    int i;
    char num[20];
    printf("请输入需要查询的车牌号：");
    scanf("%s", num);
    printf("\n\n");
    char flag = '*';
    while(flag == '*')
    {
        printf("正在为您查询场内车辆......\n");
        sleep(1);
        for(i = 0; i <= park->top; i++)
        {
            if(strcmp(num, park->pinfo[i].carnum) == 0)
            {
                printf("车牌号：%s 进入时间：%s \n",park->pinfo[i].carnum, park->pinfo[i].intime);
                break;
            }
        }
        if(i == park->top + 1)
        {
            printf("场内没有此车牌的车！\n");
            printf("为您查询等候队列车辆！\n");
            sleep(1);
            Node *w = wait->front->next;
            while(w)
            {
               if( strcmp(w->carnum, num) == 0)
               {
                    printf("该车正在等候停车\n");
                    printf("车牌号：%s 进入时间：%s \n",w->carnum, w->intime);
                    break;
               }
               w = w->next;
            }
            if(w == NULL)
            {
                printf("等候队列也无此车牌的车！\n");
            }
        }
        int k = 0;
        Info *L = info->next;
        printf("正在为您查询历史记录\n");
        sleep(1);
        while(L)
        {
            if(strcmp(num, L->carnum) == 0)
            {
                printf("车牌号：%s \n进入时间：%s离开时间：%s停留时间: %d\n",L->carnum, L->intime, L->outtime, L->usetime);
                k++;
            }
            L = L->next;
        }
        if(k == 0)
        {
            printf("历史记录为空！\n");
        }
        printf("输入任意键退出！\n");
        scanf(" %c", &flag);
    }
}

int AccRecord(Park *park, Info *inf)
{
    char quit = 'a';
    system("clear");
    printf("欢迎进入车辆出入记录查询系统,如需退出请按0，任意键继续\n");
    scanf(" %c", &quit);
    if(quit == '0')
    {
        return 0;
    }
    int i;
    char flag = '*';
    while(flag == '*')
    {
        printf("正在为您查询场内车辆记录......\n\n");
        sleep(1);
        for(i = 0; i <= park->top; i++)
        {
            printf("车牌号：%s 进入时间：%s \n",park->pinfo[i].carnum, park->pinfo[i].intime);
        }
        if(i == 0)
        {
            printf("场内暂无车辆！\n");
        }
        printf("正在为您查询历史往来车辆信息......\n\n");
        sleep(1);
        Info *L = inf->next;
        int k = 0;
        printf("Link length is %d\n",LinkLength(inf));
        while(L)
        {
                printf("车牌号：%s\n进入时间: %s离开时间：%s停留时间: %d\n",L->carnum, L->intime, L->outtime, L->usetime);
                L = L->next;
                k++;
        }
        if(k == 0)
        {
            printf("历史记录为空！\n");
        }
        printf("任意键退出！\n");
        scanf(" %c", &flag);
    }
    return 1;
}

int InterInfo(Park *park)
{
    char quit = 'a';
    system("clear");
    printf("欢迎进入查看场内车辆信息系统,如需退出请按0，任意键继续\n");
    scanf(" %c", &quit);
    if(quit == '0')
    {
        return 0;
    }
    int i;
    char flag = '*';
    while(flag == '*')
    {
        printf("场内车辆信息如下：\n");
        for(i = 0; i <= park->top; i++)
        {
            printf("车牌号：%s 进入时间：%s \n",park->pinfo[i].carnum, park->pinfo[i].intime);
        }
        if(i == 0)
        {
            printf("场内暂无车辆！\n");
        }

        printf("任意键退出！\n");
        scanf(" %c", &flag); 
    }
    return 1;
}

int  WaitInfo(Wait *wait)
{
    char quit = 'a';
    system("clear");
    printf("欢迎进入查看等候车辆信息系统,如需退出请按0，任意键继续\n");
    scanf(" %c", &quit);
    if(quit == '0')
    {
        return 0;
    }
    int i = 0;
    char flag = '*';
    while(flag == '*')
    {
        printf("正在为您查询等候车辆信息请稍后......\n");
        sleep(1);
        Node *N = wait->front->next;
        while(N)
        {
            i++;
            printf("车牌号：%s 进入时间：%s \n",N->carnum, N->intime);
            N = N->next;
        }
        if(i == 0)
        {
            printf("现在没有正在等候的车辆！\n");
        }
        printf("任意键退出！\n");
        scanf(" %c", &flag); 
    }
    return 1;
}

int main()
{
    system("clear");
    char choice = 'a';
    int ret;
    Park *park = NULL;
    Park *let = NULL;
    ret = ParkInit(&park);
    if(ret == failure)
    {
        printf("Park Init failure!\n\n");
        exit(1);
    }
    else
    {
        printf("停车系统初始化成功,请稍后......\n\n");
        sleep(1);
    }
    ret = ParkInit(&let);
    if(ret == failure)
    {
        printf("give way strack Init failure!\n\n");
        exit(1);
    }
    else
    {
        printf("让路系统初始化成功，请稍后......\n\n");
        sleep(1);
    }
    Wait *wait = NULL;
    ret = WaitInit(&wait);
    if(ret == failure)
    {
        printf("wait queue Init failure!\n\n");
        exit(1);
    }
    else
    {
        printf("等候系统初始化成功，请稍后......\n\n");
        sleep(1);
    }

    Info *inf = NULL;
    ret = InfoLinkInit(&inf);
    if(ret == failure)
    {
        printf("Infomation Init failure!\n");
        exit(1);
    }
    else
    {
        printf("信息记录系统初始化成功!\n");
        sleep(1);
    }
    printf("即将进入停车管理系统......\n");
    sleep(1);


    while(1)
    {
        system("clear");
        Hello();
        printf("please input your choice!\n");
        scanf(" %c", &choice);
        switch(choice)
        {
            case '1':
                EnterCar(park, wait);
                break;
            case '2':
                OutCar(park, wait, inf, let);
                break;
            case '3':
                QueryCar(park, wait, inf);
                break;
            case '4':
                AccRecord(park, inf);
                break;
            case '5':
                InterInfo(park);
                break;
            case '6':
                WaitInfo(wait);
                break;
            case '7':
                printf("感谢使用，期待下次光临！\n");
                StackClear(park);
                StackClear(let);
                StackDestroy(&park);
                StackDestroy(&let);
                ClearQueue(wait);
                DestroyQueue(&wait);
                ClearLink(inf);
                DestroyLink(&inf);
                sleep(1);
                exit(1);
                break;
            default :
                printf("输入有误，请重新输入！\n");
                sleep(1);
                break;

        }
        
    }
    return 0;
}

下面是其中包含的一些基础子函数比如初始化之类的：

#include"park.h"
/*     初 始 化 操 作        */
int ParkInit(Park **p)
{
    if(p == NULL)
    {
        return failure;
    }
    (*p) = (Park *)malloc(sizeof(Park));
    if(*p == NULL)
    {
        return failure;
    }
    (*p)->top = -1;
    (*p)->pinfo = (PInfo *)malloc(sizeof(PInfo) * 10);
    if((*p)->pinfo == NULL)
    {
        return failure;
    }
    return success;
}

int WaitInit (Wait **p)
{
    if(p == NULL)
    {
        return failure;
    }
    (*p) = (Wait *)malloc(sizeof(Wait));
    if((*p) == NULL)
    {
        return failure;
    }
    Node *q = (Node *)malloc(sizeof(Node));
    (*p)->front = (*p)->rear = q;
    q->next = NULL;
    return success;
}
int InfoLinkInit(Info **p)
{
    (*p) = (Info *)malloc(sizeof(Info));
    if((*p) == NULL || p == NULL)
    {
        return failure;
    }
    (*p)->next = NULL;
    return success;
}
/* 栈 的 操 作                */
int Push(Park *p, PInfo *info)
{
    if(p == NULL || info == NULL || p->top == 9)
    {
        return failure;
    }

    p->top++;
    p->pinfo[p->top] = *info;
    return success;
}


int EmptyStack(Park *p)
{
    if(p == NULL)
    {
        return failure;
    }
    return (p->top == -1) ? TRUE :FALSE;
}
int Pop(Park *p)
{
    if(p == NULL || p->top == -1)
    {
        return failure;
    }
    p->top--;
    return success;
    
}
int StackClear(Park *s)
{
    if (NULL == s)
    {
        return failure;
    }
    s->top = -1;
    return success;
}

int StackDestroy(Park **p)
{
    if((*p) == NULL || p == NULL)
    {
        return failure;
    }

    free ((*p)->pinfo);
    free((*p));
    return success;
}
/*    队 列 操 作                   */
int QueueInsert(Wait *p, Node *info) //info->next = NULL;
{
    if(p == NULL)
    {
        return failure;
    }
    Node *q = info;
    p->rear->next = q;
    q->next = NULL;
    p->rear = q;
    return success;
}

int DeleteQueue(Wait *p)
{
    if(p == NULL || p->rear == p->front)
    {
        return failure;
    }
    Node *q = p->front->next;
    p->front->next = q->next;
    if(q->next == NULL)
    {
        p->rear = p->front;
    }
    free (q);
    return success;
}

int QueueEmpty(Wait *q)
{
    if (q == NULL)
    {
        return failure;
    }
    return (q->front == q->rear) ? TRUE : FALSE;
}

int ClearQueue(Wait *p)
{
    if(p == NULL || p->front == p->rear)
    {
        return failure;
    }
    Node *q = p->front->next;
    while(q)
    {
        p->front->next = q->next;
        free(q);
        q = p->front->next;
    }
    p->rear = p->front;
    return success;
}

int DestroyQueue(Wait **q)
{
    if(q == NULL || (*q) == NULL)
    {
        return failure;
    }
    free((*q)->front);
    free(*q);
    (*q) = NULL;
    return success;
}
 /*  链 表 操 作                */ 
int LinkInsert(Info *q, Info *e)
{
    Info *l = q;
    if(l == NULL || e == NULL)
    {
        return failure;
    }
    while (l->next)
    {
        l = l->next;
    }

    l->next = e;
    e->next = NULL;
    return success;
}


int LinkLength(Info *l)
{
    if (NULL == l)
    {
        return failure;
    }
    int len = 0;
    Info *p = l->next;
    while (p)
    {
        len++;
        p = p->next;
    }
    return len;
}
int LinkEmpty(Info *q)
{
    return (q->next == NULL) ? TRUE : FALSE;
}


int ClearLink(Info *q)
{
    if(q == NULL)
    {
        return failure;
    }
    Info *p = q->next;
    while (p)
    {
        q->next = p->next;
        free(p);
        p = q->next;
    }
    return success;
}

int DestroyLink(Info **q)
{
    if(q == NULL || (*q) == NULL)
    {
        return failure;
    }
    free(*q);
    (*q) = NULL;
    return success;
}

 

Li X
关注
用栈和队列实现的c语言停车场
06-24
用栈和队列实现的c语言停车场 数据结构停车场 车进站出站查询
用栈和队列实现虚拟停车场系统
weixin_34304013的博客
04-12 320
学校的数据结构课程实验之一。 用到的数据结构：栈、队列 需求分析 　　设停车场内只有一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序依次排列。 　　若车场内已停满n辆汽车，则后来的汽车只能在门外便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后开入的车辆必须先退出车...
栈和队列实现的简易停车场
clh820的博客
02-11 647
#ifndef _PARKING_LOT_H_ #define _PARKING_LOT_H_ #define SIZE1 3 #define SIZE2 5 struct car //车辆信息 { char licensenum[40]; char intotime[30]; char offtime[30]; }; typedef struct car Car; struct...
模拟停车场管理系统。利用栈和队列来实现
11-30
停车场管理 题目要求： 设停车场是一个可停放n辆车的狭长通道，且只有一个大门可供汽车进出。 在停车场内，汽车按到达的先后次序，由北向南依次排列（假设大门在最南端）。 若车场内已停满n辆车，则后来的汽车要在门外的便道上等候，当有车开走时， 便道上的第一辆车即可开入。当停车场内某辆车要离开时，在它之后进去的车辆 必须先推出车场为它让路，待该辆车开出大门以后，其他车辆再按原次序返回车场。 每辆车离开停车场时，应按其停留时间的长短交费（在便道上停留的时间不收费）。 试编写程序，模拟上述管理过程。要求以顺序栈模拟停车场，以链队列模拟便道。 从终端读入汽车到达或离去的数据，每组数据包括三项：(1)是“到达”还是“离去” (2)汽车牌照号码；(3)“到达”或“离去”的时刻。与每组输入信息相应的输 出信息为：如果是到达的车辆，则输出其在停车场中或便道上的位置；如果是离去 的车辆，则输出其在停车场中停留的时间和应缴的费用。（需另设一个栈，临时停 放为让路而从车场退出的车。）
用栈和队列实现的一个停车场管理系统
11-17
数据结构中一个关于栈和队列的程序。对停车场车先入栈当栈满时在入队。如果有车离开，队列中的车就会进入到栈中
用栈和队列实现停车场管理
06-10
本主题将探讨如何利用栈和队列来实现一个停车场管理系统。栈具有“后进先出”（LIFO）的特性，而队列则遵循“先进先出”（FIFO）的原则，这两者在模拟特定场景时有其独特的优势。 首先，我们可以将停车场看作一个栈...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
栈、队列实现停车场管理系统 模拟程序
03-28
设停车场是一个可停放n辆汽车的狭长通道,且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序,依次由北向南排列(大门在最南端,最先到达的第一辆车停放在车场的最北端),若车场内已停满n辆汽车,则...
【最新编排】数据结构课程设计 栈和队列实现停车场管理系统.doc
06-18
在这个数据结构课程设计中，学生使用栈和队列来实现一个停车场管理系统。栈和队列是两种基础的数据结构，它们在计算机科学中有着广泛的应用。 首先，栈是一种后进先出（LIFO, Last In First Out）的数据结构，通常...
C语言课程作业 栈队列实现停车场.zip
最新发布
06-13
在本C语言课程作业中，我们探讨的主题是利用栈和队列来实现停车场管理系统。栈和队列是数据结构中的基本概念，它们在程序设计中扮演着重要角色，尤其是在处理有顺序约束的操作时。让我们深入了解一下这两个数据结构...
停车场的源代码（用栈和队列实现）
11-22
用栈和队列模拟简单的停车场问题，停车场上只有有限个车位，有一个便道，车位停满后车辆放入便道，便道上的车不准离开，停车场只有一个出口，当有车离开时，后面的车暂时离开车位，离开的车开走时，后面的车在进入车位。
利用队列和栈实现的简单停车管理系统
08-02
利用队列和栈实现的简单停车管理系统， 我们是
栈和队列实现停车场（2）
h674174380的博客
08-24 981
停车场管理 问题描述：停车场是一个能放n辆车的狭长通道，只有一个大门，汽车按到达的先后次序停放。若车场满了，车要停在门外的便道上等候，一旦有车走，则便道上第一辆车进入。当停车场中的车离开时，由于通道窄，在它后面的车要先退出，待它走后在依次进入。汽车离开时按停放时间收费。 基本功能要求： （1） 建立三个数据结构分别是：停放队列、让路栈、等候队列。 （2） 输入数据模拟管理过程，数据（入
栈与队列基本操作实现练习 停车场
Gary_werewolf的博客
10-08 355
汽车在停车场内按车辆达到时间的先后顺序，依次由北向南排列（大门在最南端，最先达到的第一辆车停放在车场的最北端），若车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；例如，设n=2，输入数据为(“A”,1,5), (“A”,2,10), (“D”,1, 15), (“A”,3,20), (“A”,4,25), (“D”,2, 35), (“E”,0,0), 其中：“A”表示达到（Arrival）;应注意保留一些非常有用的复用性高的模板，方便下次使用。
STL栈，队列实现停车场管理
Zheng_LH
09-22 301
【问题描述】 设停车场是一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车放在车场的最北端），若车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等待，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其他车辆再按原...
停车场（队列）
StriveBen的博客
08-02 740
#include #include #include #include #include #include #include using namespace std; int main() {     char c[10],d[20];     int n,m,i,k,num;     while(~scanf("%d%d",&n,&m))     {    
停车场（栈和队列实现）
m0_62645012的博客
03-25 2954
直接运行无需改动
栈和队列实现停车场两种方案（1）
h674174380的博客
08-23 2912
停车场管理 问题描述：停车场是一个能放n辆车的狭长通道，只有一个大门，汽车按到达的先后次序停放。若车场满了，车要停在门外的便道上等候，一旦有车走，则便道上第一辆车进入。当停车场中的车离开时，由于通道窄，在它后面的车要先退出，待它走后在依次进入。汽车离开时按停放时间收费。 基本功能要求： （1） 建立三个数据结构分别是：停放队列、让路栈、等候队列。 （2） 输入数据模拟管理过程，数据（入
栈与队列实现停车场问题
剑魄未改的博客
04-15 2443
使用栈和队列实现停车场问题 申明：代码我是运行成功了的，但是直接复制粘贴是肯定运行不了的，嘻嘻嘻。没想到吧O(∩_∩)O。那么接下来我将为大家介绍代码内容。 首先，实现栈与队列的基本功能。 实现栈与队列的首要条件便是结构体的配置，以下是带了注释的配置。（我们此处采用的是链表栈已经顺序队列） 队列图示 栈图示 /* * To change thi...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值