雅安人才网

要知道1小时停车场有多少辆车;还需要知道什么l?现在停了15o辆车,停车1小

    发布时间:2020-03-21

    #include "stdafx.h"
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<conio.h>
    //#include<window.h>
    #define MAXSTACKSIZE 10 //车库容量
    #define price 0.1 //每车每分钟费用

    typedef struct time{

    int hour;

    int min;

    }Time; //时间结点

    typedef struct{

    char num[10];

    Time reach;

    Time leave;

    }CarNode; //车辆信息结点

    typedef struct{

    CarNode *base;

    CarNode *top;

    int stacksize;

    }SqStackCar; //模拟车站

    typedef struct car{

    CarNode *data;

    struct car *next;

    }QueueNode;

    typedef struct{

    QueueNode *front;

    QueueNode *rear;

    }LinkQueueCar; //模拟便道

    void InitStack(SqStackCar *s) //初始化栈
    {

    s->base=(CarNode*)malloc(MAXSTACKSIZE*sizeof(CarNode));

    if(!s->base)

    printf("error");

    s->top=s->base;

    s->stacksize=MAXSTACKSIZE;

    }

    int Push(SqStackCar *s,CarNode *e) //进站操作
    {

    if(s->top-s->base>=s->stacksize)

    return 0;

    else *s->top++=*e;

    return 1;

    }

    int Pop(SqStackCar *s,CarNode *e) //出站操作
    {

    if(s->top==s->base)

    return 0;

    *e=*--s->top;

    return 1;

    }

    int StackEmpty(SqStackCar s) //判断栈空
    {

    if(s.base==s.top)

    return 1;

    else

    return 0;

    }

    int InitQueue(LinkQueueCar *Q) //初始化便道
    {

    Q->front=Q->rear=(QueueNode*)malloc(sizeof(QueueNode));

    if(!Q->front)

    printf("error");

    Q->front->next=NULL;

    return 1;

    }

    int EnQueue(LinkQueueCar *Q,CarNode *e) //便道插入函数
    {

    QueueNode *p;

    p=(QueueNode*)malloc(sizeof(QueueNode));

    if(!p)

    printf("error");

    p->data=e;

    p->next=NULL;

    Q->rear->next=p;

    Q->rear=p;

    return 1;

    }

    int DeQueue(LinkQueueCar *Q,CarNode *e) //便道删除操作
    {

    QueueNode *p;

    if(Q->front==Q->rear)

    return 0;

    p=Q->front->next;

    e=p->data;

    Q->front->next=p->next;

    if(Q->rear==p)

    Q->rear=Q->front;

    free(p);

    return 1;

    }

    int Arrive(SqStackCar *In,LinkQueueCar *Wait) //车辆到达操作
    {

    CarNode *i;

    QueueNode *w;

    i=(CarNode*)malloc(sizeof(CarNode));

    flushall(); //清除缓存位置

    printf("Input the car number:");

    gets(i->num);

    if(In->top-In->base<MAXSTACKSIZE) //车场未满,车辆进栈

    {

    printf("\nThe time the car arrive(00:00):");

    scanf("%d%d",&i->reach.hour,&i->reach.min);

    Push(In,i);

    printf("\nCar in success!");

    // Sleep(1);

    return 1;

    }

    else //停车场已满,车进便道

    {

    w=(QueueNode*)malloc(sizeof(QueueNode));

    w->data=i;

    Wait->rear->next=w;

    Wait->rear=w;

    printf("The PART is full,car must wait in the road!");

    //sleep(1);

    return 1;

    }

    return 0;

    }

    int Departure(SqStackCar *In,SqStackCar *temp,LinkQueueCar *Wait) //车辆离开操作
    {

    int flag=0,a1,a2,b1,b2;

    double money;

    CarNode *p,*t;

    QueueNode *q;

    p=(CarNode*)malloc(sizeof(CarNode));

    flushall();

    printf("Input the out car number:");

    gets(p->num);

    while(!StackEmpty(*In))

    {

    t=(CarNode*)malloc(sizeof(CarNode));

    Pop(In,t);

    if(strcmp(p->num,t->num)==0) //比较车场中有无这辆车,有即出站

    {
    printf("\nThe time the car leave(00:00):");

    scanf("%d%d",&p->leave.hour,&p->leave.min);

    printf("The");

    printf("%s",p->num);

    printf("Car out the part!");

    a1=p->leave.hour;

    b1=p->leave.min;

    a2=t->reach.hour;

    b2=t->reach.min;

    money=((a1-a2)*60+(b1-b2))*price; //计算车辆需要的费用

    printf("\nThe time the car arrive:%d:%d",t->reach.hour,t->reach.min);

    printf("\nThe time the car leave:%d:%d",p->leave.hour,p->leave.min);

    printf("\n应交费用为:%2.1f yuan",money);

    flag=1;

    getch();

    free(t);

    break;

    }

    else

    printf("不相同则进入便道:\n");

    Push(temp,t);

    }

    if(!flag)

    {

    printf("No this car!!\n");

    getch();

    }

    while(!StackEmpty(*temp))

    {

    Pop(temp,p);

    Push(In,p);

    }

    free(p);

    if(flag&&Wait->front!=Wait->rear) //车站中有空位,便道有车,车入站

    {

    q=(QueueNode*)malloc(sizeof(QueueNode));

    q=Wait->front->next;

    t=q->data;

    if(q!=NULL)
    {

    Push(In,t);

    printf("\nThe");

    printf("%s",t->num);

    printf("car in part!");

    printf("\nInput the time the car arrive(00:00):");

    scanf("%d:%d",&t->reach.hour,&t->leave.min);

    }

    Wait->front->next=q->next;

    if(q==Wait->rear)Wait->rear=Wait->front;

    free(q);

    }

    return 1;

    }

    void List1(SqStackCar *s,SqStackCar *temp)
    {

    CarNode *t;

    t=(CarNode*)malloc(sizeof(CarNode));

    int count=1;

    if(!StackEmpty(*s))

    {
    printf("\n车场:");

    printf("\n 位置到达时间 车牌号\n");

    while(!StackEmpty(*s)) //打印停车场中的车辆
    {
    Pop(s,t);

    Push(temp,t);

    }

    while(!StackEmpty(*temp))
    {
    Pop(temp,t);

    printf("The");

    printf("%d",count);

    printf(" %d:%d ",t->reach.hour,t->reach.min);

    printf("car number is: ");

    count++;

    puts(t->num);

    Push(s,t);

    }

    }

    else printf("\n车场里没有车");

    }

    void List2(LinkQueueCar *W) //打印便道中的车辆
    {
    QueueNode *p;

    int count=1;

    p=W->front->next;

    if(W->front!=W->rear)

    {

    while(p!=NULL)

    {
    printf("\nThe");

    printf("%d",count);

    printf("car number is: ");

    puts(p->data->num);

    count++;

    p=p->next;

    }

    }

    else printf("\n便道里没有车.");

    }

    void List(SqStackCar &S,SqStackCar &temp,LinkQueueCar &W) //打印操作
    {
    int flag,tag;

    flag=1;

    while(flag)

    {
    printf("\n请选择 1|2|3:");

    printf("\n1.车场列表\n2.便道列表\n3.返回主菜单\n");

    while(1)

    {
    printf("your choice:");

    scanf("%d",&tag);

    if(tag>=1||tag<=3) break;

    else printf("\n请选择 1~3:");
    }

    switch(tag)

    {

    case 1:List1(&S,&temp);break;

    case 2:List2(&W);break;

    case 3:flag=0;break;

    default: break;

    }

    }

    }

    void main() //主函数操作
    {
    SqStackCar Enter,temp;

    LinkQueueCar Wait;

    int ch;

    InitStack(&Enter);

    InitStack(&temp);

    InitQueue(&Wait);

    while(1)

    {

    printf("\n1. 车辆到达登记");

    printf(" 2. 车辆离开登记");

    printf(" 3. 车辆列表显示");

    printf(" 4. 退出系统\n");

    while(1)

    {

    scanf("%d",&ch);

    if(ch>=1&&ch<=4)

    break;

    else printf("\n请选择: 1~4.");

    }

    switch(ch)

    {

    case 1:Arrive(&Enter,&Wait);break;

    case 2:Departure(&Enter,&temp,&Wait);break;

    case 3:List(Enter,temp,Wait);break;

    case 4:exit(0);

    default: break;

    }

    }

    }

    回复:

    数据结构的
    停车场管理的
    要求的是什么
    任务是

    回复:

     .front||; next=p;     汽车 /if(; 汽车到达时间
          
    }
    void number; ,arrivaltime; ,time_a;<进  .3 数据结构
      由于停车场只有一个大门;rear; endl;if(q; <L;
     /   &e) /endl;time_a;<====================== &sl;endl;return;    .h>!",那么后来的车只能在门外的便道上等候; " {
     ,则输出汽车在停车场内或便道上的停车位置; cout< .h>    
    / &w) 
     .rear-> /duilie{ money<<queueptr 把元素e压入s栈
    {
     
     
     arrivaltime< endl;
    {  queueptr endl,检查停车场是否已满;number;<\
     struct{
       ** endl< >  
      &st;/ 
    typedef <   next,根据便道停车的特点; cin>    ,先进停车场的后退出;  <  。排在停车场中间的车辆可以提出离开停车场;==================================================="
      &q.top++=e;zanInode  **  便道的队列的对头
         
     ;如果停车场已满; cout<
       ' q;<</停车场的通道为空 
      endl;/ ;  进入或离开的标识;cin>   "/ number=number;cin>,队列以链表结构实现;把元素的插入队列(属性为number;/车牌为; 'zanInode   程序 
      ; ,D;}
     
     **" ",符合栈的“后进先出;   &q)  .number=w->
     <
    #include<,该车先停在便道的第"<.3 停车场管理
    2; ,因此;  struct{
     > /,zanInode  {
     endl;exit(0); 
     ,则排在便道上的第一辆车即可开入;q;   .stacksize_curren<,然后这些车辆依原来到达停车场的次序进入停车场;push(stackhead <p-> ,其它车辆再按原次序进入车场;; 。
    2;if(st; ,每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用;q; {
     q;p-> next=NULL,ar_time)
    {
     汽车进车场
     int ".top=L;  /  "/ time_d<
     "line;{
     E'
     ,按照从终端读入的输入数据序列进行模拟管理; < | return;对进入停车场的汽车的处理.length=0;--- int  停车场的堆栈底
      endl;**   :"next,先排队的车辆先离开便道进入停车场;><  构造便道队列line
    while(m)
    {
     ;当停车场内某辆车要离开时;case    st堆栈为停车场;/".base) &q) 汽车到达时间
    }zanInode;<e=*--L;  
    }
    void <stdio; L; ,e);  /出场的时刻,可以用一个栈来模拟停车场;  pop(st; <
    }
    void   /popqueue(linkqueue  .front=q; ,e),time_a); 
     L;  把倒车场的车倒回停车场
     <汽车车号
      stdlib;q;  2)
     L; 
     <" /,因此;<  endl; cout<   ,slinshi.stacksize_curren<{
     / endl; *next;}
      :若是车辆到达; 
      e; 
    {
       应付(元)|" L;cout<q为便道队列
          ,E);number,且只有一个大门可供汽车进出; 。每一组输入数据包括三个数据项; *base;  <.front-> .number==number)
     "< 把元素的插入队列(属性为number,待该辆车开出大门外;endl;<把临时堆栈的第一辆车(要离开的)去掉;
     :" :"/
     .length++; string;{
      \ .stacksize_curren< cout< q_to_s; &st;汽车  ,int &L) //number; :"exit(0);/<cout<,再检查在便道上是否有车等候,number;flag;"    <  queueptr  
     。试为停车场编制按上述要求进行管理的模拟程序; ,当停车场内某辆车要离开时;<  ,q_to_s); ;
    void "  !p)  main()
    {
    int  
     < ; 
    }stackhead;stacksize_curren;<: cout<break; struct   ;
    {
     
     < ;|   "  <"  .front=q;}

     <  cout< endl<"/构造一个空栈
    {
     / ,stackhead   cout<" ,依次由北向南排列(大门在最南端; 
    }*queueptr,e);   /   <  /< q; < /<车牌为" :(A;  ""  
     <!=0) 
     if(q;出车场时刻 < " /,e);   < : ar_time;/  next=p->front; 
    /.ar_time=time_a;/    
      <m--; .3; 号车道"<把元素e弹出s栈
    {
      车牌为,ar_time)
    {
     ,所以很显然保存让路车辆的场地也应该用一个栈来模拟;"  /e; 
      <:  cout<  -----------------------------------------------------"      :
      ①当车辆要进入停车场时;A 
    char <cout<<<,一旦有车开走;
    }
    void  ,zanInode  .length<!q; 
     {
     <  。
    #include<!L; **     ; <    .3; endl; pop(stackhead 
     "}
     m=100;
     initqueue(linkqueue    ,再让该车退出停车场,如果未满则车辆进入停车场; q;<,time_d; time_d;sting:" .ar_time)*2;  /iostream,w);<st;|  *top; :汽车“到达”或“离去”信息;cout<2&&q;       p=(queueptr)malloc(sizeof(duilie)); .3,后进车场的先退出; ,linkqueue "  .2 设计思路
      停车场的管理流程如下;构造停车场堆栈sting
    initstack(slinshi); <汽车车号
     int n |  
     
     ,flag=1; if(L;
    }
    }
    2;<  的车已从通道进入停车场;<   .number<&L;
     number; |",则输出汽车在停车场内停留的时间和应交纳的费用(在便道上停留的时间不收费);if(st.front->{
     if(e;case   
    #include <   w;cin>
     q_to_s;构造倒车场堆栈slinshi
    initqueue(line); /   ,则车辆进入便道等候;   <.rear==p)  便道的队列的队尾
       / <  "ar_time=ar_time;出 !;
     struct <<E .stacksize_curren--; < .rear;   队列的定义;<
     <   exit(0); / /<  
    }
    void     ==================================================="  
     ,因此在前面已设的一个栈和一个队列的基础上,继续来到的其它车辆只能停在便道上;flag=0;arrivaltime=e;   / 
       pop(sl;==================================================="
    #include<'" ,所在的停车位为; .1 项目简介
      设停车场是一个可以停放n辆汽车的南北方向的狭长通道.h>.h>,在它之后进入的车辆必须先退出车场为它让路;switch(flag)
     
       ,让路的所有车辆再按其原来进入停车场的次序进入停车场;队列的基本操作; 模拟停车场的堆栈的性质;
    initstack(sting);"  <      int  
     。之后;"<
    #include<p=q;p->
      
     }
     / ;cout< zanInode <,有车则让最先等待的那辆车进入停车场;}
      
      
    }
    /.length--; <    1  "停留时间  ,e); ,后进后出”的操作特点;
     ,linkqueue .top==L; 
     cout< 
       / <number;p;<.rear)
     length;< 
        .base) >     ,若车场内已停满n辆车;/;
    typedef > ,还需要有一个地方保存为了让路离开停车场的车辆;  < ;
    }linkqueue; queueptr ;
    void 
     /    / </likai(stackhead 、汽车牌照号码以及到达或离去的时刻;退出 ;若是车辆离去;/
    }

    void  endl,在它之后进入的车辆必须先退出车场为它让路;
    #define n   .ar_time;   pop(sl;  
      .stacksize_curren</  进场的时刻;     
     <<else
         int  ,先进后出”的操作特点.stacksize_curren=0;/停车场为空       /cout<,int 该车已进入停车场在; 
     q;number;  zanInode   / < /push(st;**"   math;  ;
    stackhead   
      
       
        ,由于先退出停车场的后进入停车场;
     ,queueptr  .ar_time=time_d;  push(st。而当停车场满后; 停车场的堆栈顶
        ,slinshi;  。因此;<   popqueue(q;e)  ,并且停车场内在要离开的车辆之后到达的车辆都必须先离开停车场为它让路;| "D' /: .base=(zanInode*)malloc(size*sizeof(zanlind));".number=number;构造一个空队列   ,便道上的车开进入停车场
     ,并弹出停车场栈
       。汽车在停车场内按车辆到达时间的先后顺序; " money=(time_d-e; </ " /.rear)    < int <,以队列模拟车场外的便道; 堆栈的基本操作; ,以及某辆车离开停车场时应缴纳的费用和它在停车场内停留的时间;
    linkqueue // ,本题求解过程中需用到两个栈和一个队列;| }
     likai(sting.top;<**"**" number;enqueue(q:    *L; 。栈以顺序结构实现。对每一组输入数据进行操作后的输出信息为;  
     cout<
     
      w=p;  size   .rear=p;cout< 
    }
    void 
     !q,最先到达的第一辆车停放在车场的最北端);if(;**" .4 程序清单
      程序提示;  e,money;D  < :以栈模拟停车场;cout<<  对离开的汽车的处理;cout<    "
        q;  endl; {
      ,符合队列的“先进先出;   push(sl;/   .length;    ;
    typedef ,line);duilie " 
     int  ;      .stacksize_curren)   A'
     车场 "  /q_to_s;  while(flag)     找到要开出的车;flag;
      ;
      st;/ 车场   }
     .h>}
      
     / |进车场时刻   int 收   停车场位置数
    /next=NULL;  endl;p;/  
     jinru(sting.stacksize_curren++;  .rear=(queueptr)malloc(sizeof(duilie));/ 。要求程序输出每辆车到达后的停车位置(停车场或便道上);q。
    2;  ===================================================="车牌号; exit(0);ar_time) 
      ,先让在它之后进入停车场的车辆退出停车场为它让路;
    typedef 请选择 cout<break; | <,line);/  number<  <  
      
     cout<if(;    模拟便道的队列的性质;  case  / cout<<  "  initstack(stackhead   /    <<time_d-arrivaltime<</.3.base;;cout<,q_to_s;   
     ;
     。
    2;    ; while(sl; queueptr e;  ! ; ---  /"  
      cin> !"据"
     停车场已满;       /--- cout< 停车场有空位;汽车出车场
     "endl;"  .front->endl; &q) ar_time;&q; 
       。
      ②当车辆要求出栈时;   push(st;<停车场管理程序 .front==q;
          ,可以用一个队列来模拟便道;  个位置上" "   
     endl< &L;
     ,sl堆栈为倒车场
     struct ق   enqueue(linkqueue 停车场和临时倒车场堆栈的定义; endl;<zanlind{ jinru(stackhead    ,e);  :     **   .3;/

    回复:

    100分 不够类···呵呵

    有个一两W的差不多 ,一个这样的源代码 市面价值都是三五万以上的·

    给你看点未完成的程序吧 自己看着挑有用的东西吧

    //头文件
    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>

    //函数返回状态代码
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    #define INFEASIBLE -1
    #define OVERFLOW -2

    #define SIZE 5//停车场位置数
    typedef int Status;

    //栈,模拟停车场
    typedef struct Car1{//车
    int number;//汽车车号
    int ar_time;//汽车到达时间
    }CarNode;
    typedef struct{//停车场
    CarNode *base;//停车场的堆栈底
    CarNode *top;//停车场的堆栈顶
    int stacksize;
    }Park;

    //队列,模拟便道
    typedef struct Car2{//车
    int number;//汽车车号
    int ar_time;//汽车到达时间
    struct Car2 *next;
    }*CarPtr;
    typedef struct{//便道
    CarPtr front;//便道的队列的对头
    CarPtr rear;//便道的队列的队尾
    int length;
    }Shortcut;

    Status InitStack(Park &P){//初始化停车场
    P.base=(CarNode*)malloc(SIZE*sizeof(Car1));
    if(!P.base) exit(OVERFLOW);
    P.top=P.base;
    P.stacksize=0;
    return OK;
    }

    Status Push(Park &P,CarNode e){//车进入停车场
    *P.top++=e;
    ++P.stacksize;
    return OK;
    }

    Status Pop(Park &P,CarNode &e){//车离开停车场
    if(P.top==P.base)
    printf("停车场为空。");
    else
    {
    e=*--P.top;
    --P.stacksize;
    }
    return OK;
    }

    Status InitQueue(Shortcut &S){//初始化便道
    S.front=S.rear=(CarPtr)malloc(sizeof(Car2));
    if(!S.front||!S.rear) exit(OVERFLOW);
    S.front->next=NULL;
    S.length=0;
    return OK;
    }

    Status EnQueue(Shortcut &S,int number,int ar_time){//车进入便道
    CarPtr p;
    p=(CarPtr)malloc(sizeof(Car2));
    if(!p) exit(OVERFLOW);
    p->number=number;
    p->ar_time=ar_time;
    p->next=NULL;
    S.rear->next=p;
    S.rear=p;
    ++S.length;
    return OK;
    }
    Status DeQueue(Shortcut &S,CarPtr &w){//车离开便道
    CarPtr p;
    if(S.front==S.rear)
    printf("通道为空。");
    else
    {
    p=S.front->next珐缉粹垦诔旧达驯惮沫;
    w=p;
    S.front->next=p->next;
    --S.length;
    if(S.rear==p) S.front=S.rear;
    }
    return OK;
    }

    Status Arrival(Park &P,Shortcut &S){//对进站车辆的处理
    int number,ar_time;
    printf("请输入车牌号:");
    scanf("%d",&number);
    printf("进场的时刻:");
    scanf("%d",&ar_time);
    if(P.stacksize<SIZE)
    {
    CarNode c;
    c.number=number;
    c.ar_time=ar_time;
    Push(P,c);
    printf("该车应停在第%d号车道。\n",P.stacksize);
    }
    else
    {
    EnQueue(S,number,ar_time);
    printf("停车场已满,请暂时停在便道的第%d个位置。\n",S.length);
    }
    return OK;
    }

    Status Leave(Park &P,Park &P1,Shortcut &S){//对离站车辆的处理
    int number,le_time,flag=1,money,ar_time;
    printf("请输入车牌号:");
    scanf("%d",&number);
    printf("出场的时刻:");
    scanf("%d",&le_time);
    CarNode e,m;
    CarPtr w;
    while(flag)
    {
    Pop(P,e);
    Push(P1,e);
    if(e.number==number)
    {
    flag=0;
    money=(le_time-e.ar_time)*2;
    ar_time=e.ar_time;
    }
    }
    Pop(P1,e);
    while(P1.stacksize)
    {
    Pop(P1,e);
    Push(P,e);
    }
    if(P.stacksize<=10&&S.length!=0)
    {
    DeQueue(S,w);
    m.ar_time=le_time;
    m.number=w->number;
    Push(P,m);
    printf("车牌号为%d的车已由便道进入停车场,停车位为%d\n",m.number,P.stacksize);
    }
    printf("停车费为%d\n",money);
    return OK;
    }

    void main()
    {
    int m=1;
    char flag;//选项
    Park P,Q;
    Shortcut S;
    InitStack(P);
    InitStack(Q);
    InitQueue(S);

    while(m)
    {
    printf("\n 停车场管理程序 \n");
    printf("===============================================\n");
    printf("** A 汽车进车场 **\n");
    printf("** **\n");
    printf("** D 汽车出车场 **\n");
    printf("** **\n");
    printf("** E 退出程序 **\n");
    printf("===============================================\n");
    printf("请选择(A,D,E): ");
    scanf("%c",&flag);
    switch(flag)
    {
    case 'A': Arrival(P,S);break; //车进入停车场
    case 'D': Leave(P,Q,S);break; //车离开停车场
    case 'E': m=0;
    }
    }
    }

    回复:

    /*----------------------------------------------------------------
    // Copyright (C) 2009 沈阳工程学院信息安全工作室
    // 版权所有。
    //
    // 文件名:模拟停车场问题.cpp
    // 文件功能描述:模拟停车场问题
    //
    //
    // 创建标识:20091214
    //
    // 修改标识:20091218
    // 修改描述:完成编码
    //----------------------------------------------------------------*/

    //头文件
    #include <iostream>
    #include <malloc.h>
    #include <string>
    #include <windows.h>

    //常量定义
    #define MAX_STOP 4 //定义停车场最大停车数
    #define MAX_PLATE 10 //定义车牌号最大长度
    #define TIME_COUNT "秒" //定义时间单位
    #define TIME_MS_TO_CONUT 1000 //定义时间进制,意为由TIME_COUNT到毫秒的进制
    #define UNIT_PRICE 10 //定义单位时间收费标准

    using namespace std; //使用std命名空间

    //数据结构定义
    //定义存储汽车信息的结构体
    typedef struct
    {
    char license_plate[MAX_PLATE]; //汽车牌照号码,定义为一个字符指针类型
    char state; //汽车当前状态,字符p表示停放在停车位上,字符s表示停放在便道上,每辆车的初始状态用字符i来进行表示
    int time; //汽车停入停车场时的时间,用来计时收费
    }CAR;

    //定义模拟停车场的栈结构
    typedef struct
    {
    CAR STOP[MAX_STOP]; //汽车信息的存储空间
    int top; //用来指示栈顶位置的静态指针
    }SeqStack;

    //定义模拟便道的队列结构
    typedef struct node
    {
    CAR WAIT; //汽车信息的存储空间
    struct node *next; //用来指示队列位置的动态指针
    }QNode; //链队列节点的类型
    //定义链队列的收尾指针
    typedef struct
    {
    QNode *front,*rear;
    }LQueue; //将头尾指针封装在一起的链队

    //函数声明
    int Empty_LQueue(LQueue *q); //判队空
    int LeaveCheck(SeqStack parking , char *license_plate); //检查离开的车是否在停车场中
    int QueueLength(LQueue *q); //判队长度
    int Out_LQueue(LQueue *&sidewalk , char *license_plate); //出队操作
    int StackEmpty(SeqStack parking); //判断栈是否为空
    int StackFull(SeqStack parking); //判断栈是否为满
    int StackPop(SeqStack &parking); //出栈操作
    int StackTop(SeqStack parking , char *license_plate , int &time);//取栈顶元素
    void Car_come(SeqStack &parking , LQueue *&sidewalk); //有车到来时的操作
    void Car_leave(SeqStack &parking , LQueue *&sidewalk); //有车离开的操作
    void Display(SeqStack parking); //显示停车场内的所有信息 调试时用
    void InitStack(SeqStack &parking); //初始化栈
    void InitList(LQueue *&sidewalk); //初始化队列
    void In_LQueue(LQueue *&sidewalk , char *license_plate); //进队操作
    void Input_Check(char *license_plate); ////检验输入的车牌是否合法
    void StackPush(SeqStack &parking , char *license_plate , int stop_time);//进栈操作

    void main()
    {
    //定义变量
    SeqStack parking;
    LQueue *sidewalk = NULL;
    char *choice = new char;
    int flag = 1; //定义一个变量 判断是否退出

    //初始化一个为空的停车场
    InitStack(parking);
    //初始化一个为空的便道
    InitList(sidewalk);

    //运行界面及功能选择
    while(flag)
    {
    cout<<"\n\t 停车场模拟管理系统 \n\n";
    cout<<"\t|--------------------------------------------------|\n\n";
    cout<<"\t|本程序为停车场的模拟管理系统,有车到来时请按C键。|\n\n";
    cout<<"\t|然后根据屏幕提示进行相关操作,有车要走时请按l键。|\n\n";
    cout<<"\t|然后根据屏幕提示进行相关操作,查看停车场请按D键。|\n\n";
    cout<<"\t|然后根据屏幕提示进行相关操作,要退出系统请按Q键。|\n\n";
    cout<<"\t|--------------------------------------------------|\n\n";
    cout<<"请选择操作:";
    gets(choice);
    if(1 != strlen(choice))
    {
    cout<<"请正确输入选项!";
    continue;
    }
    else
    {
    switch(*choice)
    {
    case 'c':
    case 'C':
    {
    Car_come(parking,sidewalk);break;
    }
    case 'l':
    case 'L':
    {
    Car_leave(parking,sidewalk);break;
    }
    case 'q':
    case 'Q':
    {
    flag=0;break;
    }
    case 'd':
    case 'D':
    {
    Display(parking);break;
    }
    default:
    cout<<"选择不正确!请重新选择!\n";
    }
    }
    }
    }
    //有车到来时的操作
    void Car_come(SeqStack &parking , LQueue *&sidewalk)
    {
    //定义变量
    char license_plate[MAX_PLATE];

    cout<<"请输入车辆的车牌号码:";
    Input_Check(license_plate);
    //判断停车场是否已满,满则进入便道,不满进入停车场
    if(StackFull(parking))
    {
    In_LQueue(sidewalk , license_plate); //进入便道
    cout<<"停车场已满请在便道等候,您的位置为"<<QueueLength(sidewalk)
    <<endl;
    }
    else
    {
    StackPush(parking , license_plate , GetTickCount()); //进入停车场
    cout<<"请进入停车场中的"<<parking.top+1<<"号停车位\n";
    }
    // Display(parking);
    }

    //有车离开时的操作
    void Car_leave(SeqStack &parking , LQueue *&sidewalk)
    {
    //定义变量
    SeqStack tmpparking; //定义临时停车场
    char leave_license_plate[MAX_PLATE]; //要离开的车牌号
    char license_plate[MAX_PLATE]; //存放从停车场中读出来的车牌信息
    int time;

    InitStack(tmpparking); //初始化临时停车场
    //判断停车场中是否有车
    if(StackEmpty(parking))
    {
    cout<<"当前停车场中没有车\n";
    return; //退出子函数
    }

    cout<<"请输入要离开的车牌照:";
    Input_Check(leave_license_plate);
    cout<<"当前停车场中有"<<parking.top+1<<"辆车\n";

    if(LeaveCheck(parking , leave_license_plate)) //判断车是否在停车场中
    {
    //车在停车场中
    cout<<"您的车在"<<LeaveCheck(parking , leave_license_plate)<<"号车位上\n";
    while(StackTop(parking , license_plate , time)
    && (strcmp(parking.STOP[parking.top].license_plate , leave_license_plate) != 0))
    {
    strcpy(parking.STOP[parking.top].license_plate , license_plate);
    cout<<"牌照为"<<license_plate<<"的车暂时退出停车场"<<parking.top+1<<"号位\n";
    StackPush(tmpparking , license_plate , time); //停车场中的车暂时退出 进入临时停车场
    StackPop(parking); //出栈
    }

    cout<<"牌照为"<<license_plate<<"的车离开停车场"<<parking.top+1<<"号位\n";
    cout<<"您在停车场中停了"<<(GetTickCount()-time)/TIME_MS_TO_CONUT<<TIME_COUNT<<endl; //输出所停时间信息
    cout<<"应缴费用为"<<(GetTickCount()-time)/TIME_MS_TO_CONUT*UNIT_PRICE<<"元\n";; //输出费用信息
    StackPop(parking); //出栈
    //将临时停车场中的车停回停车场
    while(StackEmpty(tmpparking) != 1)
    {
    StackTop(tmpparking , license_plate , time);
    StackPush(parking , license_plate , time);
    cout<<"牌照为"<<license_plate<<"的车进入停车场"<<parking.top+1<<"号位\n";
    license_plate[0] = '\0';
    StackPop(tmpparking);
    }

    if(parking.top+1 == MAX_STOP-1) //判断车离开前停车场是否停满
    if(QueueLength(sidewalk)) //如果停满则判断便道上是否有车
    {
    //便道中有车 则从便道中停入停车场
    Out_LQueue(sidewalk , license_plate); //出队
    StackPush(parking , license_plate , GetTickCount()); //入栈
    cout<<"在便道中牌照为"<<license_plate<<"的车进入停车场"<<parking.top+1<<"号位\n";
    }
    }
    else
    //车不在停车场中
    cout<<"您的车不在停车场中!\n";
    }

    //初始化顺序栈
    void InitStack(SeqStack &parking)
    {
    parking.top = -1;
    }

    //判栈空
    int StackEmpty(SeqStack parking)
    {
    if(parking.top == -1)
    return 1;
    else
    return 0;
    }

    //判栈满
    int StackFull(SeqStack parking)
    {
    if(parking.top == MAX_STOP-1)
    return 1;
    else
    return 0;
    }

    //入栈
    void StackPush(SeqStack &parking , char *license_plate , int stop_time)
    {
    parking.top++;
    strcpy(parking.STOP[parking.top].license_plate , license_plate);
    parking.STOP[parking.top].state = 'p';
    parking.STOP[parking.top].time = stop_time;
    }

    //出栈 返回栈顶指针
    int StackPop(SeqStack &parking)
    {
    if(StackEmpty(parking))
    return 0;
    else
    return parking.top--;
    }

    //取栈顶元素
    int StackTop(SeqStack parking , char *license_plate , int &time)
    {
    if(StackEmpty(parking))
    return 0;
    else
    {
    strcpy(license_plate , parking.STOP[parking.top].license_plate);
    time = parking.STOP[parking.top].time;
    return 1;
    }
    }

    //显示所有
    void Display(SeqStack parking)
    {
    if(parking.top == -1)
    printf("停车场为空\n");
    else
    {
    while(parking.top != -1)
    {
    cout<<"车牌号为:"<<parking.STOP[parking.top].license_plate;
    cout<<",停在"<<parking.top + 1 <<"号车位上";
    cout<<",已停"<<(GetTickCount()-parking.STOP[parking.top].time)/TIME_MS_TO_CONUT<<TIME_COUNT<<endl;
    parking.top--;
    }
    }
    }

    //初始化队列
    void InitList(LQueue *&sidewalk)
    {
    sidewalk = (LQueue *)malloc(sizeof(LQueue));
    sidewalk->front=sidewalk->rear = NULL;
    }

    //入队
    void In_LQueue(LQueue *&sidewalk,char *license_plate)
    {
    QNode *car_on_sidewalk;
    car_on_sidewalk = (QNode *)malloc(sizeof(QNode)); //为新节点开辟新空间
    strcpy(car_on_sidewalk->WAIT.license_plate , license_plate); //将数据写入节点
    car_on_sidewalk->WAIT.state = 's'; //写入停车信息
    car_on_sidewalk->WAIT.time = GetTickCount(); //写入停车时间
    car_on_sidewalk->next = NULL;
    if(Empty_LQueue(sidewalk)) //队空则创建第一个节点
    sidewalk->front = sidewalk->rear = car_on_sidewalk;
    else
    {
    //队非空插入队尾
    sidewalk->rear->next = car_on_sidewalk;
    sidewalk->rear = car_on_sidewalk;
    }
    }

    //判队空
    int Empty_LQueue(LQueue *q)
    {
    if(q->front == NULL)
    return 1;
    else
    return 0;
    }

    //判队长度 返回队长
    int QueueLength(LQueue *q)
    {
    QNode *p=q->front;
    int i=0;
    while(p != NULL)
    {
    i++;
    p=p->next;
    }
    return i;
    }

    //出队 成功返回1 队空返回0
    int Out_LQueue(LQueue *&sidewalk,char *licen珐缉粹垦诔旧达驯惮沫se_plate)
    {
    QNode *car_on_sidewalk;

    if(Empty_LQueue(sidewalk)) //如果队空返回0
    return 0;

    car_on_sidewalk = sidewalk->front;
    strcpy(license_plate , car_on_sidewalk->WAIT.license_plate);//取出队头元素
    if(sidewalk->front == sidewalk->rear) //队中只有一个元素
    sidewalk->front = sidewalk->rear=NULL; //删除元素
    else
    sidewalk->front = sidewalk->front->next; //队头指针后移
    free(car_on_sidewalk); //释放指针
    return 1;
    }

    //检查离开的车是否在停车场中 返回车在停车场中位置 不在则返回0
    int LeaveCheck(SeqStack parking,char *license_plate)
    {
    int flag = parking.top+1; //定义变量记录当前车在停车场中位置

    if(StackEmpty(parking))
    return 0;
    else
    {
    //查找离开车所在位置
    while(parking.top != -1 && strcmp(parking.STOP[parking.top].license_plate , license_plate) != 0)
    {
    flag--;
    parking.top--;
    }
    return flag;
    }
    }

    //检验输入的车牌是否合法
    void Input_Check(char *license_plate)
    {
    int flag = 1;
    int i;
    string tmpstr;
    while(flag)
    {
    cin>>tmpstr;
    getchar();
    if(tmpstr.length()<MAX_PLATE)
    {
    for(i=0;i<10;i++)
    license_plate[i] = tmpstr.c_str()[i];
    flag = 0;
    }
    else
    cout<<"输入有误,请重新输入:";
    }
    }

    以前的课设 你看看吧 纯手工的~~

    回复:

    进入时间,
    lpCarNode-> i++ )
    {
    printf( " 根据在停车场内的停留时间 nContinuanceMinutes (分钟)计算费用
    double CalculateExpense( int nContinuanceMinutes )
    {
    return nContinuanceMinutes * ( 5;

    LPTCARSTACK lpCarStack = NULL; ); /,
    lpCarNode->!= NULL;nEffectiveSize = 0;
    int nContinuanceMinutes = nDepartureTime - nEntranceTime;t[车牌号]\0' ), tempcarinfo );/
    carinfo = lpTemp->.szRegistrationMark;lpRear-> 若栈 lpCarstack 空;是否收费;
    printf( " )
    {
    break;t[进入(开始计费)时间]\[车位]\!= '
    puts( "
    InitStack( lpTempCarStack; / );
    lpCarStack = NULL;n"
    }

    strcpy( carinfoOut; );n' )!= strcmp( carinfoOut;

    typedef struct carstack
    {
    LPTCARINFORMATION lpCarInformation;/lpCarInformation[i];nEffectiveSize == 0;%d", TCARINFORMATION &carinfo )
    {
    carinfo = lpCarStack->nTop + 1
    ).\ / /
    }
    free( lpCarQueue );lpHead; i <

    typedef struct carqueue /lpNext = NULL;n按任意键退出程序;n'
    if ( 0 ;t是",返回 TRUE.szDepartureTime; )
    {
    puts( "

    LPTCARSTACK lpTempCarStack = NULL; lpCarNode = lpNextCarNode )
    {
    lpNextCarNode = lpCarNode->, tempcarinfo ), carinfo;否则;

    TCARINFORMATION carinfoOut = { NULL };t[进入(开始计费)时间]\
    strcpy( tempcarinfo;
    printf( " (区分大小写);lpNext;

    sscanf( lpTime;否则;徐沙利 - Build201006\/
    sscanf( szUserInput;

    if ( cCommandType == ' );
    lpCarStack->, carinfo );
    }
    putchar( '
    lpCarStack->, 将其容量设置为 nSize
    void InitStack( LPTCARSTACK &lpCarStack;t%s\;
    }

    / ), carinfo;********************":\
    printf( "
    }

    /nTop; 将字符串时间格式转换为数字(分钟)格式;t%s\
    }
    putchar( ',我们刚做完这个题目; 清空当前屏幕
    #define ClearScreen() system( ".\
    puts( ".szRegistrationMark );
    }

    /
    for ( LPTCARNODE lpCarNode = lpCarQueue->
    puts( "carinfo, nParkCapability ).szEntranceTime, *LPTCARINFORMATION;
    scanf( ", carinfo; );
    #include <, *LPTCARNODE; );
    puts( ".szEntranceTime );;\/lpHead->
    puts( "
    printf( "n' //t\,用链队模拟
    InitQueue( lpCarQueue );
    puts( "
    scanf( ",返回 FALSE
    BOOL IsStackFull( LPTCARSTACK lpCarStack )
    {
    return lpCarStack->t[车牌号]\.szDepartureTime );D'
    }

    if ( FALSE == bIsCarFound )
    {
    printf( "n" 栈容量
    } TCARSTACK,冀A1234; 或 't\ / lpCarNode ;请输入停车场容量:\.\A'

    return nHour * 60 + nMinute;lpHead->/.szDepartureTime );
    free( lpTemp );windows;malloc;/, carinfoOut ),用栈模拟
    InitStack( lpCarStack;/,即车辆信息
    ); ).szDepartureTime, tempcarinfo ), int nSize )
    {
    lpCarStack = ( LPTCARSTACK ) malloc( sizeof ( TCARSTACK ) );n"停放时间; );
    puts( "t===========欢迎你进入停车场管理系统===========\, carinfo; 若栈 lpStackFull 满;/ /,getch()

    typedef struct carinformation / 初始化栈 lpCarStack;\/
    puts( "carinfo;\t%s\ ); 当前队中元素个数
    } TCARQUEUE;/
    puts( "

    / 将命令类型与车辆信息分开存放
    "
    lpCarQueue = NULL, carinfo;
    puts( "t%;t\/
    #include <已进入停车场第 %d 个车位\n"[命令类型]"
    Pause( "
    }
    else
    {
    EnQueue( lpCarQueue;
    }

    /lpHead; 车辆信息
    int nTop; 用户输入的后半部分;nEffectiveSize
    );\t\
    DestroyQueue( lpCarQueue );= lpCarStack-> ).\
    printf( "%c;:"E"; / ); ); 链队
    {
    LPTCARNODE lpHead;lpNext; 初始化链队 lpCarQueue
    void InitQueue( LPTCARQUEUE &lpCarQueue )
    {
    lpCarQueue = ( LPTCARQUEUE ) malloc( sizeof( TCARQUEUE ) );/--------------------" ).":"n"\n",返回 FALSE
    BOOL IsStackEmpty( LPTCARSTACK lpCarStack )
    {
    return lpCarStack->\输入信息有误;D - 车辆离开"lpNext;请输入命令;nTop] = carinfo;lpCarInformation[i];--------------------\.szRegistrationMark;n"cls" ); / );t%s\ /.szRegistrationMark );%s"0't[到达时间]\
    Push( lpCarStack;;carinfo; ), carinfoOut;nEffectiveSize--;
    lpCarQueue->, carinfo ); )., / )
    {
    ClearScreen().szArrivalTime ); 显示字符串 szPrompt 并等待用户按下任意键
    #define Pause( szPrompt ) printf( "!发给你看看; 存储本次用户输入的车辆信息

    strcpy( carinfo.szEntranceTime );.第一个字符只能为 ' 进入停车场(开始计费)时间
    char szDepartureTime[16];lpCarInformation[i];/.szRegistrationMark ):\ );

    return 0;/;
    double rExpense = CalculateExpense( nContinuanceMinutes );n"车牌号:26"
    lpCarQueue->.h>O't%s\,14;

    char cCommandType = NULL; );;lpNext )
    {
    nNum++;
    putchar( 'nTop++; 车辆信息
    {
    char szRegistrationMark[64], TCARINFORMATION carinfo )
    {
    LPTCARNODE lpCarNode = ( LPTCARNODE ) malloc( sizeof( carnode ) );
    continue, szUserInput );;lpCarInformation[lpCarStack->:一定要采纳哦, "

    /
    }

    /lpCarInformation = ( LPTCARINFORMATION ) malloc(
    nSize * sizeof ( TCARINFORMATION )
    ); / 队头元素从链队 lpCarQueue 中出队并存入 carinfo
    void DeQueue( LPTCARQUEUE &lpCarQueue;应交纳的费用;t\是否收费; 离开时间
    } TCARINFORMATION;
    }

    //n' 用户输入的前半部分;carinfo;lpRear = lpCarQueue->
    puts( "; ); 车辆信息从栈 lpCarStack 中弹出并存入 carinfo
    void Pop( LPTCARSTACK &lpCarStack; );
    putchar( ' //n按任意键输入下一条信息;/:\E - 停止输入",
    lpCarStack-> 销毁栈 lpCarStack; 车辆信息
    struct carnode *lpNext;车牌号为 %s 的车未进入停车场;
    printf( "\.szEntranceTime,16; / 停车场;/ );
    free( lpCarNode );/
    puts( ", lpCommaLocation + 1 ); 便道.0 / );
    }
    }
    else if ( cCommandType == ');lpNext = lpTemp-> )
    {
    strcpy( carinfo;
    lpCarQueue->
    puts( "nTop == -1; );n"
    } while ( TRUE );t\.szRegistrationMark,已停放在便道的第 %d 个车位\n".szArrivalTime, tempcarinfo );D'--------------------"
    for ( LPTCARNODE lpCarNode = lpCarQueue->,
    &cCommandType; 车辆信息 carinfo 入栈 lpCarStack
    void Push( LPTCARSTACK &lpCarStack;
    lpCarQueue->); 头结点
    LPTCARNODE lpRear;/\:\,返回 TRUE.szDepartureTime;lpNext!嘿嘿
    #include <A'/
    for ( int i = 0;[便道使用情况]\,即命令类型
    szCarInformation /, rExpense ).szRegistrationMark ) )
    {
    Push( lpTempCarStack;
    printf(",
    lpCarNode->

    char szCarInformation[128] = { NULL }; 栈顶元素下标
    int nStackSize;[车位]\
    puts( " /,
    tempcarinfo;--------------------\n', &nHour;
    Push( lpCarStack;t%s\ 指向下一个元素的指针
    } TCARNODE;
    printf( " /
    lpCarStack-> 车辆信息字符串中的逗号位置

    for ( lpCommaLocation = szCarInformation; ); 到达时间
    char szEntranceTime[16],冀A1234.szDepartureTime ); )

    /,%s", *LPTCARQUEUE; 销毁链队 lpCarQueue
    void DestroyQueue( LPTCARQUEUE &lpCarQueue )
    {
    LPTCARNODE lpNextCarNode = NULL;
    int nNum = 0;nTop == ( lpCarStack->
    }

    typedef struct carnode /nStackSize = nSize;/
    }

    /.;t%s\nTop--;
    puts( ",
    lpCarQueue->t%s\lpHead-> 车牌号
    char szArrivalTime[16];n'
    puts( ",返回 FALSE
    BOOL IsQueueEmpty( LPTCARQUEUE lpCarQueue )
    {
    return lpCarQueue->lpCarInformation );lpRear->:\
    int nEntranceTime = ConvertTimeFormat( carinfoOut;--------------------"conio; );停放在便道的第 1 个车位; 车辆信息 carinfo 入队 lpCarQueue
    void EnQueue( LPTCARQUEUE &lpCarQueue; 命令类型
    char szUserInput[128] = { NULL };例.szArrivalTime );\n';/n" 或 ';n', *LPTCARSTACK;/.szEntranceTime
    );\
    lpCarStack->
    }

    /\n"A;)真巧;
    DeQueue( lpCarQueue.h>n":\
    lpCarStack->, &nMinute );t\
    }

    int main( void )
    {
    int nParkCapability = 0;
    putchar( '

    if ( FALSE == IsQueueEmpty( lpCarQueue ) )
    {
    TCARINFORMATION tempcarinfo = { NULL };D;
    }
    }

    while ( FALSE == IsStackEmpty( lpTempCarStack ) )
    {
    TCARINFORMATION tempcarinfo = { NULL };n"n"//O - 显示当前停车场和便道使用情况"
    lpCarQueue->.1lf 元\, szPrompt ); /,返回 TRUE;lpRear = lpCarQueue->
    lpCarNode ;O"O'
    puts( ".;
    printf( "; );

    DestroyStack( lpCarStack );n"
    Pop( lpTempCarStack;
    printf( "[停车场使用情况]\
    }
    else
    {
    bIsCarFound = TRUE; );
    puts( ",
    lpCarStack->.h>
    int nMinute = 0;
    }
    else
    {
    puts( "lpNext;
    while ( FALSE == IsStackEmpty( lpCarStack ) )
    {
    Pop( lpCarStack; 停车场容量

    putchar( 'E' 指向当前队尾的指针
    int nEffectiveSize;
    #include <
    break;\
    }
    else if ( cCommandType == '%s"t%s - %s (共 %d 分钟)\否则;\, TCARINFORMATION carinfo )
    {
    lpCarStack->车牌号;t否"
    break,', &nParkCapability );lpHead->
    printf( " /\
    printf( "
    putchar( ' 60 ), carinfo; *lpCommaLocation ;t%s\

    if ( FALSE == IsStackFull( lpCarStack ) )
    {
    strcpy( carinfo;lpNext = lpCarNode;
    printf(",车牌号为 %s 的车已进入停车场\,将指针 lpCarStack 置为 NULL
    void DestroyStack( LPTCARSTACK &lpCarStack )
    {
    free( lpCarStack->
    putchar( '//计费时段; )
    {
    strcpy( carinfo;lpCarInformation[lpCarStack->carinfo = carinfo.;

    TCARINFORMATION carinfo = { NULL }.h>.szEntranceTime
    ),
    lpCarStack->
    lpCarNode->/stdio;//.szArrivalTime;
    lpCarQueue->.szRegistrationMark;/.szEntranceTime;t\%d:";/n".h> 或 'n"; lpCommaLocation++ )
    {
    if ( *lpCommaLocation == ', carinfo;
    }
    Pause( "停车场已满;/
    lpCarQueue->;n按任意键输入下一条信息;
    printf( ", carinfoOut );n"stdlib;t%s\
    puts( " lpCarNode = lpCarNode->

    LPTCARQUEUE lpCarQueue = NULL.szRegistrationMark
    ); ); 用户输入
    do
    {
    ClearScreen();
    int nDepartureTime = ConvertTimeFormat( carinfoOut,
    nContinuanceMinutes
    ),
    i + 1,例如 12;%d\lpHead = ( LPTCARNODE) malloc( sizeof( TCARNODE ) );
    }

    /********************"t 徐沙利 20074470149\ ),
    lpCarStack->:36 将被转换为 756 ( 12 * 60 + 36 )
    int ConvertTimeFormat( char *lpTime )
    {
    int nHour = 0; /, /
    }
    }
    else if ( cCommandType == '

    Pause( "nEffectiveSize++, lpCommaLocation + 1 );n"
    }

    /, szCarInformation ):\n'

    /n" /,
    nNum,
    carinfoOut;

    BOOL bIsCarFound = FALSE;
    Push( lpCarStack:51"

    char *lpCommaLocation = NULL; ):%d"
    putchar( '/, carinfo, TCARINFORMATION &carinfo )
    {
    LPTCARNODE lpTemp = lpCarQueue->A - 车辆到达"E',
    carinfoOut;/.szArrivalTime; 链队结点信息
    {
    TCARINFORMATION carinfo; );nStackSize - 1 );nTop = -1;
    }

    /
    lpCarQueue->);/!= NULL;
    puts( "t[到达时间]\n"/
    puts( "
    lpCarQueue->nTop];%d\, nParkCapability );;
    free( lpCarStack );
    }
    }
    *lpCommaLocation = '/lpNext = NULL; 若链队 lpCarQueue 为空;
    lpCarNode->
    #include <

    回复:

    2.3 停车场管理 2.3.1 项目简介 设停车场是一个可以停放n辆汽车的南北方向的狭长通道,且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序,依次由北向南排列(大门在最南端,最先到达的第一辆车停放在车场的最北端),若车场...

    回复:

    /*---------------------------------------------------------------- // Copyright (C) 2009 沈阳工程学院信息安全工作室 // 版权所有。 // // 文件名:模拟停车场问题.cpp // 文件功能描述:模拟停车场问题 // // // 创建标识:20091214 // /...

    回复:

    真巧,我们刚做完这个题目!发给你看看:一定要采纳哦!嘿嘿 #include #include #include #include #include // 清空当前屏幕 #define ClearScreen() system( "cls" ) // 显示字符串 szPrompt 并等待用户按下任意键 #define Pause( szPrompt ) p...

      上一篇:001184基金看哪个股票 下一篇:杀手4为什么 打开了左上角一直闪耀着一个小窗口?! 很烦人 我家xp系统 一开始很好现在开始闪耀了

      返回主页:雅安人才网

      本文网址:http://0835job.cn/view-48142-1.html
        信息删除