zoukankan      html  css  js  c++  java
  • 数据结构之停车场

    程序设计思想:  

      1.首先定义一个数据类型包含车牌号和进去的时间,这两个车的信息。  

      2.定义栈一用来模仿停车场的入栈函数(其中包含入队函数,栈满则入队),栈二用来储存栈一出来元素的入栈函数。  

      3.两个栈的有共同的出栈函数。  

      4.定义队列(模仿便道)的入队与出队函数  

      5.在主函数中调用时间函数用来记录时间  

      6.定义两个栈和一个队列,同时初始化。  

      7.提示用户输入车牌号,利用while不停的输入(输入的同时记下输入时间),直到输入end为止。  

      8.在while循环中给用户提供进车,出车,结束的三个选择。  

      9.出车: 提示用户输入出车的车牌号  

      10.将栈一的栈顶元素出栈,判断是否与想要的车牌号一致,相同则执行下一步,不相同执行第十三步。  

      11.调用time函数记录出车时间再减去入车时间得到停车时间,停车时间乘以倍数得到费用。  

      12.判断便道上是否有车,有车则队头元素进入停车场,否则,提示用户车场有空位。  

      13.利用while循环将栈一出来的元素储存到栈二中,直到得到想要的车牌号,计算停车费用。  

      14.将栈二中的元素再返回到栈一中。  

      15.判断队列是否为空,若不为空将队头元素进入到栈一中,否则提示用户停车场有空位。  

      16.入车: 判断便道是否为空,若空判断栈一是否已满不满,则进入停车场,提示进入成功,否则下一步。  

      17.车辆进入便道,提示: 停车场已经满将车停在便道上  

      18.设置取栈顶元素函数,用来测试所有元素是否按设计思想移动。

       遇到的问题:   

      1.程序的反复进出栈,入队,出队,比较繁琐。   

      2.对于记录一段时间的函数不会应用。   

      3.对于记录时间的函数取整可能为0 ,导致收费为0,所以设置最低收费标准为1元。   

      4.对于逻辑判断不太清楚。对于停车场内没有找到车,输出  该车不在停车场中  出现了问题。   因为要判断是否栈的顶指针与头指针是否重合,以及车牌是否找到,这两个判断间的与和或关系有点混乱.

      5.对于判断车辆没有找到出现了问题,没有解决。

       启发:   

      1.对于比较复杂但是有思路的程序一定要静下心来仔细思考,不要把程序的编写顺延,等一会做会比现在做   要花费更大的时间和精力。   

      2.对于编程过程中的问题要及时记下,否则过一会就忘记了。   

      3.对于记录一段时间函数的应用解决:    

        定义 clock_t start,finish;     s

          tart 用在程序的开始     

          finish 用在程序的结尾          

          time=(double)finish-start/CLOCKS_PER_SEC;

    #include <iostream>
    #include <string>
    #include <ctime>
    using namespace std;
    #define max 3
    
    typedef struct        //定义车辆的信息数据类型,包括车牌号和进去时间
    {                    //该程序只设计了两个信息,利用车牌号将车取出,时间计算应该缴纳的费用
        string num;
        double time;
    }data;
    
    typedef struct            //定义顺序栈的数据类型
    {
        data *base;
        data *top;
        int stacksize;
    }SqStack;
    
    typedef struct QNode        //定义链队的数据类型
    {
        data point;
        struct QNode *next;
    }QNode,*QueuePtr;
    
    typedef struct
    {
        QueuePtr front;
        QueuePtr rear;
    }LinkQueue;
    
    void InitStack(SqStack &s)        //顺序栈的初始化函数
    {
        s.base=new data[max];
        if(!s.base)
        {
            cout<<"栈申请空间失败,程序结束!"<<endl;
            exit(0);
        }
        s.top=s.base;
        s.stacksize=max;
    }
    
    void InitQueue(LinkQueue &q)        //链队的初始化函数
    {
        q.front=q.rear=new QNode;
        q.front->next=NULL;
    }
    
    void EnQueue(LinkQueue &q,data e)            //链队的进队函数
    {
        QueuePtr p=new QNode;
        p->point=e;
        p->next=NULL;
        q.rear->next=p;
        q.rear=p;
    }
    
    void Push1(SqStack &s,data e,LinkQueue &q)        //一栈的入栈函数
    {
        if(s.top-s.base==s.stacksize)
        {
            EnQueue(q,e);
        }
    
        else
        {
            *s.top++=e;
        }
    }
    
    void Push2(SqStack &s,data e)            //二栈的入栈函数,不用判断是否栈满
    {
        *s.top++=e;
    }
    
    data Pop(SqStack &s)            //两个栈的出栈函数
    {
        data e;
        e=*--s.top;
    
        return e;
    }
    
    
    data DeQueue(LinkQueue &q)                //链队的出队函数,将判断队是否为空放在主函数中
    {
        data e;
        QueuePtr p=new QNode;
        p=q.front->next;
        e=p->point;
        q.front->next=p->next;
        if(q.front==p)
            q.rear=q.front;
    
        delete p;
        return e;
    }
    
    data Get(SqStack s)            //测试函数,检测栈中元素是否正确的进出
    {
        return *(s.top-1);
    }
    int main()
    {
        clock_t start,        //定义时间用来计算车辆停留时间
                finish;
        LinkQueue q;        //链队的定义和初始化
        InitQueue(q);
    
        SqStack s1,            //两个顺序栈的定义和初始化
                s2;
        InitStack(s1);
        InitStack(s2);
    
        data e;
        cout <<"请输入车辆的信息(车牌号,如果输入完毕请输入end点enter)"<<endl;
        while(e.num!="end")
        {
            cin>>e.num;            
            start=clock();            //记录进去的时间
            e.time=start;
            Push1(s1,e,q);            //入栈操作
        }
        if(s1.top-s1.base==max)
        {
            cout<<"停车场只能停"<<max<<"辆车,多余的车辆进入便道!"<<endl;
        }
        
        int choice;
        data t1;
        string name;
        while(1)
        {
            cout <<"-------------------------------------------------------------------------------"<<endl;
            cout <<"1. 车辆出去        2 车辆进去        3.  结束"<<endl;
            
            cout <<"请输入你的选择:";
            cin>>choice;
    
            if(choice == 3)
            {
                exit(0);
            }
            else if(choice==1)
            {
                
                cout <<"请输入要出车的车牌号:";
                cin>>name;
                t1=Pop(s1);
                if(t1.num==name)            //判断栈顶是否是要出的车辆
                {
                    finish=clock();
                    double money;                            //计算停车费用
                    money=(double)(finish-t1.time)/CLOCKS_PER_SEC;
                    money=(int)money/10+1;
                    cout<<"停车费用为:"<<money<<""<<endl;
                    cout <<"车辆出去成功!"<<endl;
                                                            //测试位置,检测是否出车成功
                    if(q.front==q.rear)            //判断便道上是否有车
                    {
                        cout <<"停车场有多余空间进车."<<endl;        //没有车则停车场产生空位
                    }
                    else
                    {
                        Push2(s1,DeQueue(q));        //便道上有车则向停车场内补齐
                        cout <<"停车场没有空位!"<<endl;
                    }
                                                    //测试位置,出车成功后检测便道上的车是否进入停车场
                }
                else
                {
                    while(t1.num!=name&&s1.base!=s1.top)            //顶上元素不是想要的元素,则将出栈元素储存在栈二中
                    {                                                //继续向下寻找
                        Push2(s2,t1);
                        t1=Pop(s1);
                    }
                    
                    finish=clock();
                    double money;                            //计算时间
                    money=(double)(finish-t1.time)/CLOCKS_PER_SEC;
                    money=(int)money/10+1;
                    cout<<"停车费用为:"<<money<<""<<endl;
                    cout <<"车辆出去成功!"<<endl;    
                                                        //寻找到则出车成功
            
                    while(s2.top!=s2.base)            //将栈二内的元素放回到栈一中
                    {
                        Push1(s1,Pop(s2),q);
                    }
                                                //测试位置,判断栈二中元素是否全都放回栈一中
                    if(q.front==q.rear)            //出车成功后判断便道上是否有车
                    {
                        cout <<"停车场有多余空间进车."<<endl;    //没车则停车场产生空位
                    }
                    else
                    {
                        Push2(s1,DeQueue(q));                //有车则向停车场中补齐
                        cout <<"停车场没有空位!"<<endl;
                    }
                }
                                                        //测试位置,检测便道上的车是否进入停车场中
            }
    
            else if(choice == 2)
            {
                cout <<"请输入您的车牌号:";
                data d;
                cin>>d.num;
                if(q.front!=q.rear)
                {
                    cout <<"停车场内部已满,您的车只能停在便道上."<<endl;
                    EnQueue(q,d);
                }
                else
                {
                    if(s1.top-s1.base!=s1.stacksize)
                    {
                        Push1(s1,d,q);
                        start=clock();
                        d.time=start;
                        cout <<"您的车已成功停在停车场."<<endl;
                    }
                    else
                    {
                        cout <<"停车场内部已满,您的车只能停在便道上."<<endl;
                        EnQueue(q,d);
                    }
                }
            }
            else
            {
                cout <<"无此功能!"<<endl;
                break;
            }
        }
    
        return 0;
    }


     

  • 相关阅读:
    剑指Offer-11.二进制中1的个数(C++/Java)
    剑指Offer-10.矩形覆盖(C++/Java)
    剑指Offer-9.变态跳台阶(C++/Java)
    UVA 1608 Non-boring sequence 不无聊的序列(分治,中途相遇)
    UVA1607 Gates 与非门电路 (二分)
    UVA 1451 Average平均值 (数形结合,斜率优化)
    UVA 1471 Defense Lines 防线 (LIS变形)
    UVA 1606 Amphiphilic Carbon Molecules 两亲性分子 (极角排序或叉积,扫描法)
    UVA 11134 FabledRooks 传说中的车 (问题分解)
    UVA 1152 4 Values Whose Sum is Zero 和为0的4个值 (中途相遇)
  • 原文地址:https://www.cnblogs.com/dotacai/p/4908337.html
Copyright © 2011-2022 走看看