实习二 栈、队列和递归算法设计 （题目：停车场管理 ）

最新推荐文章于 2021-10-19 20:51:08 发布
最新推荐文章于 2021-10-19 20:51:08 发布
阅读量478 收藏 4
点赞数 1
文章标签： c/c++ 数据结构与算法
原文链接：http://www.cnblogs.com/XDJjy/archive/2013/04/07/3005987.html
版权

一、需求分析

     1.每一组输入数据包括：汽车“到达”或“离去”信息、汽车牌照号码以

及到达或离去的时刻。

     2.输出信息：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用。        

     3.测试数据

      设n=2，输入数据为：（‘A’,1,5），（‘A’,2,10），（‘D’,1,15），（‘A’,3,20），（‘A’,4,25），（‘A’,5,30），（‘D’,2,35），（‘D’,4,40），（‘E’,0,0）。其中：‘A’表示到达；‘D’表示离去；‘E’表示输入结束。

     4.【选作内容】：两个栈共享空间，思考应开辟数组的空间是多少？

     5.【选作内容】：停放在便道上的汽车也收费，收费标准比停放在停车场的车。

View Code 
#include<stdio.h>
#include<malloc.h>
#define MaxStackSize 3            //2*n-1个值 
typedef struct               //车辆信息的结构体
{
    int number;
    int ahour;
    int alhour;
    int aminute;
    int alminute;
}Carmessage;
typedef struct                //栈的结构体
{
    Carmessage Car[MaxStackSize];
    int top1;
    int top2;
}SeqStack;
typedef struct qnode        //链式队列结点
{
    Carmessage Car;
    struct qnode *next;
}LQNode;
typedef struct              //链式队列结点指针
{
    LQNode *front;
    LQNode *rear;
    int count;
}LQueue;
 int QueueAppend(LQueue *Q,Carmessage Carx) //入队列函数
 {
     LQNode *p;
    p=(LQNode *)malloc(sizeof(LQNode));
    p->Car.number=Carx.number;
    p->Car.ahour=Carx.ahour;
    p->Car.aminute=Carx.aminute;
    p->Car.alhour=Carx.alhour;
    p->Car.alminute=Carx.alminute;
    p->next=NULL;
    Q->count++;
    if(Q->rear!=NULL)Q->rear->next=p;
    Q->rear=p;
    if(Q->front==NULL)Q->front=p;
    return 0;
 }
 int QueueAd(LQueue *Q,int lh,int lm)           //排队等候入栈的车辆，载入入栈时间 
 {
     Q->front->Car.alhour=lh;
     Q->front->Car.alminute=lm;
    return 0;    
 }
 int QueueGet(LQueue *Q,Carmessage *Cary)    //出队列
 {
     Cary->number=Q->front->Car.number;
     Cary->ahour=Q->front->Car.ahour;
     Cary->aminute=Q->front->Car.aminute;
     Cary->alhour=Q->front->Car.alhour;
     Cary->alminute=Q->front->Car.alminute;
     Q->front=Q->front->next;                        //队列头指针后移
     Q->count--;
    return 0;                                       
 }
 int StackPush(SeqStack *S,LQueue *Q,Carmessage Carx)//停车场的入栈函数
 {
     if(S->top1>=(MaxStackSize+1)/2)                  //车场停满 ,停到过道 即入队列
    QueueAppend(Q,Carx);    
     else                                       //车辆未满，入栈 S,
     {
        S->Car[S->top1].alhour=0;
        S->Car[S->top1].alminute=0;
         S->Car[S->top1].ahour=Carx.ahour;
         S->Car[S->top1].aminute=Carx.aminute;
        S->Car[S->top1].number=Carx.number;
         //*****************/!!!!!!!!!!!!!!!/
//    printf("!!!该车停车时刻：%d:%d",S->Car[S->top1].ahour,S->Car[S->top1].aminute);
        S->top1++;
        return 1;
     }
 }
 int StackPop(SeqStack *S,LQueue *Q,Carmessage *Carx)//停车场的出栈函数
 {
     int n,m;
     int kaiguan=0;
//     SeqStack Sx;
     Carmessage Cary;
//    Sx.top1=0;              //初始化用于转移车辆的栈
    if(S->top1<=0)return 2;
//    printf("%d\n",S->top1);
    for(n=S->top1;S->top1>0;S->top1--)            //寻找出栈的车牌号 (没被减)******************for管道else
    if(S->Car[S->top1-1].number==Carx->number)
    {
        Carx->ahour=S->Car[S->top1-1].ahour;//记录被删除车信息
        Carx->aminute=S->Car[S->top1-1].aminute;
        Carx->alhour=S->Car[S->top1-1].alhour;
        Carx->alminute=S->Car[S->top1-1].alminute;
//        printf("!!该车停车时刻：%d:%d",Carx->ahour,Carx->aminute);         //      ？？
        if(n!=S->top1)
      {
    //    m=n-S->top1;
       /* for(;Sx.top1<m;n--,Sx.top1++,Sx.top2--)   //转移出  多加一
        {
        Sx.Car[Sx.top1].ahour=S->Car[n-1].ahour;
         Sx.Car[Sx.top1].aminute=S->Car[n-1].aminute;
        Sx.Car[Sx.top1].number=S->Car[n-1].number;
           Sx.Car[Sx.top1].alhour=S->Car[n-1].alhour;
         Sx.Car[Sx.top1].alminute=S->Car[n-1].alminute;
        }*/
        for(;n>S->top1;n--,S->top2--) 
        {        
        S->Car[S->top2].ahour=S->Car[n-1].ahour;
         S->Car[S->top2].aminute=S->Car[n-1].aminute;
        S->Car[S->top2].number=S->Car[n-1].number;
           S->Car[S->top2].alhour=S->Car[n-1].alhour;
         S->Car[S->top2].alminute=S->Car[n-1].alminute;
            
        }
         for(S->top1--;S->top2<MaxStackSize;S->top1++,S->top2++)        //转移进//开出
        {
        S->Car[S->top1].ahour=S->Car[S->top2+1].ahour;
         S->Car[S->top1].aminute=S->Car[S->top2+1].aminute;
        S->Car[S->top1].number=S->Car[S->top2+1].number; 
           S->Car[S->top1].alhour=S->Car[S->top2+1].alhour;
         S->Car[S->top1].alminute=S->Car[S->top2+1].alminute;
         }
        S->top2--;
      }
      S->top1--;                  //开出一辆 
      kaiguan=1;
      break;
     }
     if(kaiguan==0&&S->top1==0&&S->top1<n){S->top1=n;return 2;}
     if(S->top1==(MaxStackSize-1)/2&&Q->front!=NULL)//判断是否有车等候进站
     {
           QueueGet(Q,&Cary);
         S->Car[S->top1].ahour=Cary.ahour;
         S->Car[S->top1].aminute=Cary.aminute;
         S->Car[S->top1].number=Cary.number;
         S->Car[S->top1].alhour=Cary.alhour;
         S->Car[S->top1].alminute=Cary.alminute;        
//         printf("!该车停车时刻：%d:%d",Cary.ahour,Cary.aminute); 
        S->top1++;
     }
    return 1;

 }
int main()
{
    int m,biandao,chechang;
    int lh,lm;
    char al;
    Carmessage Carx;
    SeqStack S;
    LQueue Q;
    Q.rear=NULL;                              //初始化队列 
    Q.front=NULL;
    Q.count=0;
    S.top1=0; 
    S.top2=MaxStackSize-1;                                 //初始化栈;
    printf("车到达请输入A/ 车离开请输入D/ 退出E：");
    while(scanf("%c",&al)!=EOF && al!='E') 
    {
//    al=getchar();
    if(al=='A')
    {
        printf("请输入停车时刻（例如12:12）  ");
         scanf("%d:%d",&Carx.ahour,&Carx.aminute);
        printf("请输入车牌号：");
        scanf("%d",&Carx.number);
        StackPush(&S,&Q,Carx);
        if(Q.count==0)printf("停车的位置：在停车场的%d号位\n",S.top1);
        else printf("停车的位置：在便道的%d号位\n",Q.count);
    }
    else if(al=='D')
    {
        printf("请输入离开时刻（例如12:12）  ");
         scanf("%d:%d",&lh,&lm);
         if(S.top1>=(MaxStackSize+1)/2&&Q.front!=NULL)QueueAd(&Q,lh,lm);
        printf("请输入车牌号：");
        scanf("%d",&Carx.number);
        m=StackPop(&S,&Q,&Carx);
        if(m==2)printf("无此车\n");
        else{
        printf("该车停车时刻：%d:%d\n",Carx.ahour,Carx.aminute);
        biandao=(Carx.alhour-Carx.ahour)*60+Carx.alminute-Carx.aminute;
        chechang=(lh-Carx.ahour)*60+lm-Carx.aminute;
        if(Carx.alhour==0&&Carx.alminute==0)
        {
            printf("该车在便道上停车时间：0");
            printf("该车在停车场停车时间：%d\n",chechang);
            printf("该车需缴费（停车场2元/分钟，便道1元/分钟）：%d元\n",chechang*2);
        }
        else 
        {
            printf("该车在便道上停车时间：%d\n",biandao);            
            printf("该车在停车场停车时间：%d\n",chechang-biandao);
            printf("该车需缴费（停车场2元/分钟，便道1元/分钟）：%d元\n",chechang*2-biandao);
        }        
        }
    }
    else printf("错误！！请重新输入\n");
      //  printf("\n%d\n",S.top1);
        printf("车到达请输入A/ 车离开请输入D/ 退出E：");
        scanf("%c",&al);
    }
    return 0;
}

                                                                         实习二 栈、队列和递归算法设计

     题目：停车场管理                   实习时间：2012/10/14

一、需求分析

     1.每一组输入数据包括：汽车“到达”或“离去”信息、汽车牌照号码以

及到达或离去的时刻。

     2.输出信息：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用。        

     3.测试数据

      设n=2，输入数据为：（‘A’,1,5），（‘A’,2,10），（‘D’,1,15），（‘A’,3,20），（‘A’,4,25），（‘A’,5,30），（‘D’,2,35），（‘D’,4,40），（‘E’,0,0）。其中：‘A’表示到达；‘D’表示离去；‘E’表示输入结束。

     4.【选作内容】：两个栈共享空间，思考应开辟数组的空间是多少？

5.【选作内容】：停放在便道上的汽车也收费，收费标准比停放在停车场的车。

 

二、设计

二、      1. 设计思想

二、        （1）存储结构

          以栈模拟停车场，以队列模拟车场外的便道。栈以顺序结构实现，队 列以链表结构实现。

          不需另设一个栈，栈顶空间临时停放为将要离去的汽车让路而从停车场退出来的汽车，栈用顺序存储结构实现。输入数据按到达或离去的时刻有序。栈中每个元素表示一辆汽车，包含三个数据项：汽车的牌照号码停车时刻和进入停车场的时刻。 

        （2）主要算法基本思想

            按照顺序（两栈共享空间）栈和链式队列的基本操作，初始化一个栈和一个队列，若车辆进站，先判断车站是否满，未满就进车站，满了就进过道：若车辆离开，先在站中找到该车辆，再判断队列是否空，若非空则将车从过道进到站中并记录进站的时间；若不进行车辆的进出则终止程序。

    2. 设计表示

        （1）函数调用关系图

          main→StackPush→QueueAppend→QueueAd→StackPop→QueueGet

        （2）函数接口规格说明

int StackPush(SeqStack *S,LQueue *Q,Carmessage Carx)//若车站S未满，则Carx的信息入栈；若车站S满，则Carx的信息入队列Q；         

int QueueAppend(LQueue *Q,Carmessage Carx) //Carx的信息入队列Q

int QueueAd(LQueue *Q,int lh,int lm) //队列Q中排队等候入栈的车辆，载入入栈时间 lh,lm  

int StackPop(SeqStack *S,LQueue *Q,Carmessage *Carx)// 若车站S非空，则Carx的信息出栈；若此时队列Q中有车等候入栈，则将该车入栈S。         

int QueueGet(LQueue *Q,Carmessage *Cary)    //队列非空，将Carx的信息从Q中出队列。

3. 实现注释    （即各项功能的实现程度）

      （1）可根据需要修改栈的大小（n项），只需将MaxStackSize 的值改2*n-1；

      （2）若输入的字母不是A,D,E，则提示重新输入。

（3）若栈中无输入的车牌号，则输出“无此车”，重新输入。

      4. 详细设计    （即主要算法的细化。略，见上课笔记）

【1】 int StackPush(SeqStack *S,LQueue *Q,Carmessage Carx)//停车场的入栈函数

 {

        if(S->top1>=(MaxStackSize+1)/2)   //车场停满 ,停到过道 即入队列

      QueueAppend(Q,Carx);   

        else                   //车辆未满，入栈 S,

   {

        S->Car[S->top1].alhour=0;

        S->Car[S->top1].alminute=0;

            S->Car[S->top1].ahour=Carx.ahour;

               S->Car[S->top1].aminute=Carx.aminute;

        S->Car[S->top1].number=Carx.number;

          S->top1++;

         return 1;

        }

【2】int QueueAppend(LQueue *Q,Carmessage Carx) //入队列函数

 {

          LQNode *p;

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

        p->Car.number=Carx.number;

        p->Car.ahour=Carx.ahour;

        p->Car.aminute=Carx.aminute;

        p->Car.alhour=Carx.alhour;

        p->Car.alminute=Carx.alminute;

p->next=NULL;

        Q->count++;

        if(Q->rear!=NULL)Q->rear->next=p;

        Q->rear=p;

        if(Q->front==NULL)Q->front=p;

        return 0;

    }

【3】 int StackPop(SeqStack *S,LQueue *Q,Carmessage *Carx)//停车场的出栈函数

 {

        int n,m;

        int kaiguan=0;             //用于判断是否找到相应车牌号的车

     Carmessage Cary;

    if(S->top1<=0)return 2;

        for(n=S->top1;S->top1>0;S->top1--)           //寻找出栈的车牌号    if(S- >Car[S->top1-1].number==Carx->number)

    {

    Carx->ahour=S->Car[S->top1-1].ahour;//记录被删除车信息

    Carx->aminute=S->Car[S->top1-1].aminute;

    Carx->alhour=S->Car[S->top1-1].alhour;

    Carx->alminute=S->Car[S->top1-1].alminute;

        for(;n>S->top1;n--,S->top2--)

        {         

         S->Car[S->top2].ahour=S->Car[n-1].ahour;

               S->Car[S->top2].aminute=S->Car[n-1].aminute;

        S->Car[S->top2].number=S->Car[n-1].number;

          S->Car[S->top2].alhour=S->Car[n-1].alhour;

               S->Car[S->top2].alminute=S->Car[n-1].alminute;

        }

            for(S->top1--;S->top2<MaxStackSize;S->top1++,S->top2++)//转移进//开出

      {

      S->Car[S->top1].ahour=S->Car[S->top2+1].ahour;

               S->Car[S->top1].aminute=S->Car[S->top2+1].aminute;

        S->Car[S->top1].number=S->Car[S->top2+1].number;

          S->Car[S->top1].alhour=S->Car[S->top2+1].alhour;

               S->Car[S->top1].alminute=S->Car[S->top2+1].alminute;

            }

        S->top2--;

    }

      S->top1--;                  //开出一辆

      kaiguan=1;                //找到该车

      break;

     }

     if(kaiguan==0&&S->top1==0&&S->top1<n){S->top1=n;return 2;}

     if(S->top1==(MaxStackSize-1)/2&&Q->front!=NULL)//判断是否有车等候进站

     {

          QueueGet(Q,&Cary);

           S->Car[S->top1].ahour=Cary.ahour;

            S->Car[S->top1].aminute=Cary.aminute;

            S->Car[S->top1].number=Cary.number;

           S->Car[S->top1].alhour=Cary.alhour;

            S->Car[S->top1].alminute=Cary.alminute;     

      S->top1++;

     }

    return 1;

 }

【4】int QueueGet(LQueue *Q,Carmessage *Cary)    //出队列

 {

        Cary->number=Q->front->Car.number;

        Cary->ahour=Q->front->Car.ahour;

        Cary->aminute=Q->front->Car.aminute;

        Cary->alhour=Q->front->Car.alhour;

        Cary->alminute=Q->front->Car.alminute;

        Q->front=Q->front->next;             //队列头指针后移

        Q->count--;

    return 0;                                      

 }

【5】int QueueAd(LQueue *Q,int lh,int lm) //排队等候入栈的车辆，载入入栈时间

 {

        Q->front->Car.alhour=lh;

        Q->front->Car.alminute=lm;

    return 0;

 }

三、调试分析

      1.调试过程中遇到的主要问题是如何解决的；

调试过程中存在少许C语言的基础语法错误，经独立仔细观察和调试修改正确，最大的难题是栈和队列的指针移动的条件需细心考虑，其在循环中的移动情况要考虑充分，以及地址在多个函数调用时的变化。在自己独立多次修改下，终于完成。     

2.对设计和编码的回顾讨论和分析；

在增加选作内容时，意识到在代码删改过程中，牵一发而动全身的纷繁复杂性，需要多次反复查看和检查。在今后的编程过程中要更注重代码整体设计的提纲记录，用更多的注释。

3.时间和空间复杂度的分析；

【1】入栈函数： 时间O(n),空间O(1)

       【2】入队列函数：时间O(n),空间O(n)

       【3】出栈函数：时间O(n^2),空间O(1)

       【4】出队列函数：时间O(1),空间O(1)

      4.改进设想；

此次实习需要设计的算法较少，主要是一些栈和队列的基本操作和各函数之间的调用条件（该条件或有更简洁的表示）。其它地方暂无修改办法。

5.经验和体会等。

多动手编程，才能熟练灵活的掌握C语言基础知识，才能更好的理解掌握数据结构的精髓。从而避免基础语法错误，让代码变得更简洁高效。如此才能准确高效的解决问题。在今后的编程过程中要更注重代码整体设计的提纲记录，用更多的注释。

 

四、用户手册（即使用说明）

   仅需按照提示输入大写字母和数字（输入的时间格式按12:12的时刻格式）即可。

 

五、运行结果

运行环境：C-free

【1】设n=2，输入数据为：（‘A’,1,5），（‘A’,2,10），（‘D’,1,15），（‘A’,3,20），（‘A’,4,25），（‘A’,5,30），（‘D’,2,35），（‘D’,4,40），（‘E’,0,0）。其中：‘A’表示到达；‘D’表示离去；‘E’表示输入结束。

【选作内容】：停放在便道上的汽车也收费，收费标准比停放在停车场的车。

 

 

 

 

 

若输入非’A’’D’’E’,则提示重新输入。

 

 

【2】又增选做内容，

【选作内容】：两个栈共享空间，思考应开辟数组的空间是多少？//2*n-1

【选作内容】：停放在便道上的汽车也收费，收费标准比停放在停车场的车。

【内容】若栈中无出栈的车牌号，输出提示，重新输入。

 

 

 

六、源程序清单

#include<stdio.h>

#include<malloc.h>

#define MaxStackSize 3            //2*n-1个值

typedef struct               //车辆信息的结构体

{

         int number;

         int ahour;

         int alhour;

         int aminute;

         int alminute;

}Carmessage;

typedef struct                //栈的结构体

{

    Carmessage Car[MaxStackSize];

         int top1;

         int top2;

}SeqStack;

typedef struct qnode        //链式队列结点

{

         Carmessage Car;

         struct qnode *next;

}LQNode;

typedef struct              //链式队列结点指针

{

         LQNode *front;

         LQNode *rear;

         int count;

}LQueue;

 int QueueAppend(LQueue *Q,Carmessage Carx) //入队列函数

 {

        LQNode *p;

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

         p->Car.number=Carx.number;

         p->Car.ahour=Carx.ahour;

         p->Car.aminute=Carx.aminute;

         p->Car.alhour=Carx.alhour;

         p->Car.alminute=Carx.alminute;

         p->next=NULL;

         Q->count++;

         if(Q->rear!=NULL)Q->rear->next=p;

         Q->rear=p;

         if(Q->front==NULL)Q->front=p;

         return 0;

 }

 int QueueAd(LQueue *Q,int lh,int lm)           //排队等候入栈的车辆，载入入栈时间

 {

        Q->front->Car.alhour=lh;

        Q->front->Car.alminute=lm;

    return 0; 

 }

 int QueueGet(LQueue *Q,Carmessage *Cary)    //出队列

 {

        Cary->number=Q->front->Car.number;

        Cary->ahour=Q->front->Car.ahour;

        Cary->aminute=Q->front->Car.aminute;

        Cary->alhour=Q->front->Car.alhour;

        Cary->alminute=Q->front->Car.alminute;

        Q->front=Q->front->next;                        //队列头指针后移

        Q->count--;

    return 0;                                      

 }

 int StackPush(SeqStack *S,LQueue *Q,Carmessage Carx)//停车场的入栈函数

 {

        if(S->top1>=(MaxStackSize+1)/2)                  //车场停满 ,停到过道 即入队列

         QueueAppend(Q,Carx);   

        else                                       //车辆未满，入栈 S,

          {

        S->Car[S->top1].alhour=0;

        S->Car[S->top1].alminute=0;

            S->Car[S->top1].ahour=Carx.ahour;

                 S->Car[S->top1].aminute=Carx.aminute;

        S->Car[S->top1].number=Carx.number;

         //*****************/!!!!!!!!!!!!!!!/

//      printf("!!!该车停车时刻：%d:%d",S->Car[S->top1].ahour,S->Car[S->top1].aminute);

                   S->top1++;

                   return 1;

        }

 }

 int StackPop(SeqStack *S,LQueue *Q,Carmessage *Carx)//停车场的出栈函数

 {

        int n,m;

        int kaiguan=0;

//     SeqStack Sx;

        Carmessage Cary;

//    Sx.top1=0;              //初始化用于转移车辆的栈

    if(S->top1<=0)return 2;

//    printf("%d\n",S->top1);

         for(n=S->top1;S->top1>0;S->top1--)            //寻找出栈的车牌号 (没被减)******************for管道else

    if(S->Car[S->top1-1].number==Carx->number)

    {

             Carx->ahour=S->Car[S->top1-1].ahour;//记录被删除车信息

             Carx->aminute=S->Car[S->top1-1].aminute;

             Carx->alhour=S->Car[S->top1-1].alhour;

             Carx->alminute=S->Car[S->top1-1].alminute;

//          printf("!!该车停车时刻：%d:%d",Carx->ahour,Carx->aminute);         //      ？？

        if(n!=S->top1)

      {

         //      m=n-S->top1;

            /* for(;Sx.top1<m;n--,Sx.top1++,Sx.top2--)   //转移出  多加一

             {

             Sx.Car[Sx.top1].ahour=S->Car[n-1].ahour;

                 Sx.Car[Sx.top1].aminute=S->Car[n-1].aminute;

        Sx.Car[Sx.top1].number=S->Car[n-1].number;

         Sx.Car[Sx.top1].alhour=S->Car[n-1].alhour;

                 Sx.Car[Sx.top1].alminute=S->Car[n-1].alminute;

        }*/

        for(;n>S->top1;n--,S->top2--)

        {           

                   S->Car[S->top2].ahour=S->Car[n-1].ahour;

                 S->Car[S->top2].aminute=S->Car[n-1].aminute;

        S->Car[S->top2].number=S->Car[n-1].number;

         S->Car[S->top2].alhour=S->Car[n-1].alhour;

                 S->Car[S->top2].alminute=S->Car[n-1].alminute;

                

        }

            for(S->top1--;S->top2<MaxStackSize;S->top1++,S->top2++)        //转移进//开出

             {

             S->Car[S->top1].ahour=S->Car[S->top2+1].ahour;

                 S->Car[S->top1].aminute=S->Car[S->top2+1].aminute;

        S->Car[S->top1].number=S->Car[S->top2+1].number;

         S->Car[S->top1].alhour=S->Car[S->top2+1].alhour;

                 S->Car[S->top1].alminute=S->Car[S->top2+1].alminute;

            }

        S->top2--;

           }

      S->top1--;                  //开出一辆

      kaiguan=1;

      break;

     }

     if(kaiguan==0&&S->top1==0&&S->top1<n){S->top1=n;return 2;}

     if(S->top1==(MaxStackSize-1)/2&&Q->front!=NULL)//判断是否有车等候进站

     {

         QueueGet(Q,&Cary);

            S->Car[S->top1].ahour=Cary.ahour;

            S->Car[S->top1].aminute=Cary.aminute;

            S->Car[S->top1].number=Cary.number;

            S->Car[S->top1].alhour=Cary.alhour;

            S->Car[S->top1].alminute=Cary.alminute;          

//         printf("!该车停车时刻：%d:%d",Cary.ahour,Cary.aminute);

             S->top1++;

     }

    return 1;

 

 }

int main()

{

         int m,biandao,chechang;

         int lh,lm;

         char al;

         Carmessage Carx;

         SeqStack S;

         LQueue Q;

         Q.rear=NULL;                              //初始化队列

         Q.front=NULL;

         Q.count=0;

    S.top1=0;

         S.top2=MaxStackSize-1;                                 //初始化栈;

         printf("车到达请输入A/ 车离开请输入D/ 退出E：");

         while(scanf("%c",&al)!=EOF && al!='E')

         {

//      al=getchar();

         if(al=='A')

         {

                   printf("请输入停车时刻（例如12:12）  ");

            scanf("%d:%d",&Carx.ahour,&Carx.aminute);

        printf("请输入车牌号：");

        scanf("%d",&Carx.number);

                   StackPush(&S,&Q,Carx);

        if(Q.count==0)printf("停车的位置：在停车场的%d号位\n",S.top1);

                   else printf("停车的位置：在便道的%d号位\n",Q.count);

         }

         else if(al=='D')

         {

                   printf("请输入离开时刻（例如12:12）  ");

            scanf("%d:%d",&lh,&lm);

            if(S.top1>=(MaxStackSize+1)/2&&Q.front!=NULL)QueueAd(&Q,lh,lm);

        printf("请输入车牌号：");

        scanf("%d",&Carx.number);

        m=StackPop(&S,&Q,&Carx);

        if(m==2)printf("无此车\n");

                   else{

                   printf("该车停车时刻：%d:%d\n",Carx.ahour,Carx.aminute);

                   biandao=(Carx.alhour-Carx.ahour)*60+Carx.alminute-Carx.aminute;

                   chechang=(lh-Carx.ahour)*60+lm-Carx.aminute;

                   if(Carx.alhour==0&&Carx.alminute==0)

                   {

                            printf("该车在便道上停车时间：0");

                            printf("该车在停车场停车时间：%d\n",chechang);

                            printf("该车需缴费（停车场2元/分钟，便道1元/分钟）：%d元\n",chechang*2);

                   }

                   else

                   {

                            printf("该车在便道上停车时间：%d\n",biandao);             

            printf("该车在停车场停车时间：%d\n",chechang-biandao);

                            printf("该车需缴费（停车场2元/分钟，便道1元/分钟）：%d元\n",chechang*2-biandao);

                   }                

                   }

         }

    else printf("错误！！请重新输入\n");

           //  printf("\n%d\n",S.top1);

                   printf("车到达请输入A/ 车离开请输入D/ 退出E：");

                   scanf("%c",&al);

         }

         return 0;

}

转载于:https://www.cnblogs.com/XDJjy/archive/2013/04/07/3005987.html

weixin_34032792
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
停车场计费算法 php,《算法与数据结构》课程设计之停车场的收费管理系统
weixin_42407739的博客
04-04 2347
《算法与数据结构》课程设计题目：停车场的收费管理系统一、设计目的与内容1.问题描述任务：停车场可以同时停放M辆车，停车场的入口和出口可分别有N辆车排队。停车每小时收费5元，每天不超过50元，停车不满半小时不收费，超过半小时按一小时收费。功能要求：完成停车场进出车的收费管理以及查询每辆车的停车记录(按照车牌号查询)；停车场目前的状况(满或空的车位数)。规定：输入数据形式和范围：车牌号、停车开始时间输...
C/C++用栈和队列实现停车场问题
weixin_51406612的博客
11-01 1840
问题：设停车场内只有一个可停放n 辆汽车的狭长通道，且只有一个大门可供汽车进出，汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满n 辆汽车，则后来的汽车只能在门外的便道上等候, 一旦有车开走，则排在便道上的第一辆车即可开入，当停车场内某辆车要离开时，在它之后开入的车辆必须先退出车场为它让路，待该辆车开出大门外，其它车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用，当便道上汽车要离开时，排..
数据结构C语言之停车场管理
Evil_invisible的博客
07-28 6944
停车场管理 题目描述 [问题描述] 设停车场内只有一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后开入的车辆必须先退出车场为它让路，...
用链表实现约瑟夫环程序的设计
12-24
包括设计思想 ，源代码，流程图，设计心得。数据结构课程是一门理论和实践相结合的课程。上机实验是为训练学生的实际程序设计能力安排的、包含在教学课时内的教学内容。实验目的是： （1） 进一步深入理解相关部分的基本概念和授课内容。 （2） 进一步提高实际动手进行程序设计的能力。
数据结构栈和队列（以停车场管理题目为例）
数据挖掘+大数据研发+算法学习
03-07 2128
/*实验 栈和队列实验实验目的熟悉栈和队列的基本特性，掌握栈和队列基本运算的实现过程。时间要求：4+4学时问题描述：设停车场内只有一个可停放 n 辆汽车的狭长通道，且只有一个大门可供汽车进出，汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满 n 辆汽车，则后来的汽车只能在门外的便道上等候, 一旦有车开走，则排在便道上的第...
停车场管理--栈、队列和递归算法设计
04-03
设停车场是一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端），若停车场内已停...试为停车场编制按上述要求进行管理的模拟程序。
栈、队列与递归算法设计（数制转换问题，回文判断
05-12
栈、队列和递归是三种基本的数据结构和算法，广泛应用于各种问题的解决，如数制转换和回文判断。本文将深入探讨这些概念，并结合实际例子来解释其在解决问题中的应用。 首先，栈是一种后进先出（LIFO）的数据结构，...
数据结构作业：第三章-栈和队列题目.docx
12-17
数据结构作业：第三章-栈和队列题目 本文档旨在提供一个详细的知识点总结，涵盖数据结构第三章中的栈和队列概念。通过对题目的逐一分析，我们将对栈和队列的基本概念、特点、操作和应用进行总结。 栈的基本概念 ...
python 利用栈和队列模拟递归的过程
09-20
主要介绍了python 利用栈和队列模拟递归的过程,文中并通过两段代码给大家介绍了下递归和非递归的区别，需要的朋友可以参考下
栈、队列与递归算法设计
05-04
[问题描述] 　设停车场内只有一个的停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，...试为停车场编制按上述要求进行管理的模拟程序。
简易停车场
06-18
》问题描述<br>设停车场是一个可以停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已经停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后进入的车辆必须先退出场为它让路，待该辆车开出大门外，其他车辆再按次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用，试为停车场编制按上述要求进行管理的模拟程序。<br>》基本要求<br>以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去的时刻。对一组输入数据进行操作后的输出信息为：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。栈以顺序结构实现。队列以链表结构实现。<br>》测试数据<br>设n=2，输入数据为：（‘A’，1，5）， （‘A’，2，10）， （‘D’，1，15）， （‘A’，3，20）， （‘A’，4，25）， （‘A’，5，30）， （‘D’，2，35）， （‘D’，4，40）， （‘E’，0，0）。其中：‘A’表示到达（Arrival），‘D’表示离去（Departure），‘E’表示输入结束（End）。<br>》实现提示<br>需另设一个栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车，也用顺序存储结构实现。输入数据按到达或离去的时刻有序。栈中每个元素表示一辆汽车，包含两个数据项：汽车的牌照号码和进入停车场的时刻。<br>
数据结构之停车场管理
06-04
用一个顺序栈表示停车场，队列表示便道，另设一个临时栈停放为给要离去 的汽车让路而从停车场退出来的汽车。。 自行输入停车场可以停放的车辆。。
停车场问题求解（经典算法）
09-10
停车场问题求解 停车场问题求解 停车场问题求解 停车场问题求解 停车场问题求解 停车场问题求解 停车场问题求解
停车场模拟管理系统的设计与实现
11-04
停车场模拟管理系统的设计与实现
数据结构课程设计 四题
06-09
数据结构课程设计 一,约瑟夫环 二、停车场管理 四、校园导游程序 （轻院） 一、 约瑟夫环 本次实习的主要目的在于熟悉线性表的基本运算在两种存储结构上的实现，其中以熟悉各种链表的操作为侧重点。通过本次实习还可帮助读者复习高级语言的使用方法。 [问题描述]　　约瑟夫（Joeph）问题的一种描述是：编号为1,2,…,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序。 [基本要求]　　利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。 [测试数据]　　自己设定 [实现提示]　　程序运行后首先要求用户指定初始报数上限值，然后读取各人的密码。设n≤30。 [选作内容]　　向上述程序中添加在顺序结构上实现的部分。 二、 停车场管理 仅仅认识到栈和队列是两种特殊的线性表是远远不够的，本次实习的目的在于使读者深入了解栈和队列的特征，以便在实际问题背景下灵活运用它们；同时还将巩固这两种结构的构造方法，接触较复杂问题的递归算法设计。 [问题描述] 　　设停车场内只有一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后开入的车辆必须先退出车场为它让路，待该辆车开出大门外，其它车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。试为停车场编制按上述要求进行管理的模拟程序。 [测试数据] 　　设n=2,输入数据为：（‘A’，1，5），（‘A’，2，10），（‘D’，1，15），（‘A’，3， 20）， （‘A’，4，25），（‘A’，5，30），（‘D’，2，35），（‘D’，4，40），（‘E’，0，0）。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时刻，其中，‘A’表示到达；‘D’表示离去，‘E’表示输入结束。 [基本要求] 　　以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时刻，对每一组输入数据进行操作后的输出数据为：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车离去；则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。栈以顺序结构实现，队列以链表实现。 [实现提示] 　　需另设一个栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车，也用顺序存储结构实现。输入数据按到达或离去的时刻有序。栈中每个元素表示一辆汽车，包含两个数据项：汽车的牌照号码和进入停车场的时刻。 [选作内容] 　　（1） 两个栈共享空间，思考应开辟数组的空间是多少？ 　　（2） 汽车可有不同种类，则它们的占地面积不同，收费标准也不同，如1辆客车和1.5辆小汽车的占地面积相同，1辆十轮卡车占地面积相当于3辆小汽车的占地面积。 　　（3） 汽车可以直接从便道上开走，此时排在它前面的汽车要先开走让路，然后再依次排到队尾。 　　（4） 停放在便道上的汽车也收费，收费标准比停放在停车场的车低，请思考如何修改结构以满足这种要求。 三、 员工管理系统 综合运用线性表、查找、排序的相关知识，解决一个实际应用问题。通过本次实习，要求熟练掌握线性表的存储结构，能在对应的存储结构上进行各种操作，并能分析不同的查找和排序方法的时空性能。 [问题描述] 　　每个员工的信息包括：编号、姓名、性别、出生年月、学历、职务、电话、住址等。系统能够完成员工信息的查询、更新、插入、删除、排序等功能。 [基本要求] 　　（1） 排序：按不同关键字，对所有员工的信息进行排序。 　　（2） 查询：按特定条件查找员工。 　　（3） 更新：按编号对某个员工的某项信息进行修改。 　　（4） 插入：加入新员工的信息。 　　（5） 删除：按编号删除已离职的员工的信息。 [选作内容] 　　实现图形用户界面。 四、校园导游程序 [问题描述] 　　用无向网表示你所在学校的校园景点平面图，图中顶点表示主要景点，存放景点的编号、名称、简介等信息，图中的边表示景点间的道路，存放路径长度等信息。要求能够回答有关景点介绍、游览路径等问题。 [基本要求] 　　（1） 查询各景点的相关信息； 　　（2） 查询图中任意两个景点间的最短路径。 　　（3） 查询图中任意两个景点间的所有路径。 　　（4） 增加、删除、更新有关景点和道路的信息。 [选作内容] 　　（1） 求多个景点的最佳（最短）游览路径。 　　（2） 区分机动车道和人行道。 　　（3） 实现导游图的仿真界面。
Python:(递归)长度为5的马路，平均能停多少辆长度为1的车
weixin_55638680的博客
10-19 586
题目 长度为5的马路，平均能停多少辆长度为1的车 思路 1、先分析问题，平均能停多少辆的意思是：一共停满了2000次，每一次能停下的车辆数相加除以2000就可以得到平均能停的车辆数。 2、使用递归函数实现停满一次所能停下的车辆数 3、使用while函数进行试验次数的控制，以及对车辆数的累加。 代码 import random n=0 result=0 def park_randomly(low,high): if high-low<1: return 0#停不
数据结构栈和队列、递归算法
梦想之深邃
09-25 1815
知识要点： 栈的定义、结构特点及其存储方式(顺序存储与链接存储)和基本操作的实现算法； 队列的结构、特点及其存储方式(顺序存储与链接存储)和基本操作的实现算法。 递归的基本概念和实现原理以及用递归的思想描述问题和书写算法的方法； 用栈实现递归问题的非递归解法。 栈的定义：只允许一段进行插入或者删除操作的线性表；该端称为栈顶（top），相反另一端不允许被操作的称为栈底（base） 栈内元...
应用程序课程设计--停车场管理 C语言实现
02-22
【问题描述】 　　设停车场内只有一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后开入的车辆必须先退出车场为它让路，待该辆车开出大门外，其它车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。试为停车场编制按上述要求进行管理的模拟程序。 需求分析 1.序主要模拟停车场管理系统，以栈模拟停车场，以队列模拟车场 外的便道，按照从终段读入的输入数据序列进行模拟管理。栈以顺序结构实现，队列以链表结构实现。 2． 栈与队列中的每一个元素均表示一辆汽车，其中每辆汽车的信息包含车号以及进入停车场的时间。当栈所模拟的车场内满后，外来车辆便会进入便道。 3．系统中车库的容量以及停车费用可由用户随时设定。 4．该程序中包含的命令有车辆的到达‘A’、离开‘D’和系统的结束‘E’。 5. 设n=2，输入数据为：（‘A’ 1,5）,（‘A’ 2,10）,（‘D’ 1,15）,（‘A’ 3,20）,（‘A’ 4,25）,（‘A’ 5,30）,（‘D’ 2,35）,（‘D’ 4,40）,（‘E’）。
[源码和文档分享]基于栈和队列的停车场管理系统
qq_38474647的博客
12-11 326
1 问题描述 设停车场内只有一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入。 当停车场内某辆车要离开时，在它之后开入的...
栈和队列程序设计的基本思想，原理和算法描述：
最新发布
06-10
栈和队列是常用的数据结构，它们的基本思想是用一种特定的方式存储和操作数据，以便于在程序中进行快速、高效的...总之，栈和队列是程序设计中常用的数据结构，掌握它们的基本思想、原理和算法对于程序员来说非常重要。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值