Question

我正在尝试解决我的任务中所需的队列问题。

详情如下： - 我被要求创建一个自动化强大的排队子系统（请注意，每个牙科诊所有2名医生和4个牙医椅，1个X光机在其前提下） - 时间优化算法（不同类型的处理）。例如，蛀牙需要30分钟，检查只需15分钟等。 - 每个诊所每天早上和下午分别预计约20名和约15名患者。 - 诊所时间是上午8点 - 下午12点，下午2点 - 下午6点

在询问我的讲师后，他说我需要两个队列（对于每个医生），X光机将是一个即时过程，并且在比较这两个队列时，根本不需要时间和一天结束，总持续时间的差异几乎相等。

我一直试图解决这个问题，但无济于事。有人可以解释一下如何解决这些问题吗？

编辑：

我已经创建了队列实现和一个应该排入队列的Visit类。我需要弄清楚的是如何安排所有这些访问的算法，以便队列节省时间。

Visit.h

#ifndef Visit_H
#define Visit_H

#include "MC.h"
#include "Doctor.h"
#include "Assistant.h"
#include "Condition.h"
#include "Medicine.h"
#include "Treatment.h"

class Visit
{
private:
    std::string date;
    std::string time;
    double duration;
    Staff staff;
    MC mc;
    bool xRayStatus;
    List<Treatment> treatmentList;
    List<Condition> conditionList;
    List<Medicine> medicineList;
public:
    Visit();
    Visit(std::string, std::string, double);
    std::string getDate();
    void addStaff(Staff);
    Staff getStaff();
    void setMC(MC);
    MC getMC();
    void addXRay();
    bool getXRayStatus();
    void addCondition(Condition c);
    void addMedicine(Medicine m);
    void addTreatment(Treatment t);
    List<Treatment> getTreatmentList();
    List<Medicine> getMedicineList();
    List<Condition> getConditionList();
};
#endif

Visit.cpp

#ifndef Visit_CPP
#define Visit_CPP

#include "Visit.h"

Visit::Visit()
{

}

Visit::Visit(std::string d, std::string t,  double dur)
{
    date = d;
    time = t;
    duration = dur;
}

std::string Visit::getDate()
{
    return date;
}

void Visit::addStaff(Staff s)
{
    staff = s;
}

Staff Visit::getStaff()
{
    return staff;
}

void Visit::setMC(MC m)
{
    mc = m;
}

MC Visit::getMC()
{
    return mc;
}

void Visit::addXRay()
{
    xRayStatus = true;
}

bool Visit::getXRayStatus()
{
    return xRayStatus;
};


void Visit::addCondition(Condition c)
{
    conditionList.add(c);
}

void Visit::addMedicine(Medicine m)
{
    medicineList.add(m);
}

void Visit::addTreatment(Treatment t)
{
    treatmentList.add(t);
}

List<Treatment> Visit::getTreatmentList()
{
    return treatmentList;
}

List<Medicine> Visit::getMedicineList()
{
    return medicineList;
}

List<Condition> Visit::getConditionList()
{
    return conditionList;
};

#endif

Queue.h

//Queue.h - - Specification of Queue ADT (implemented using Pointers)

#include<string>
#include<iostream>
#include "Visit.h"
using namespace std;

typedef Visit ItemType;

class Queue
{
  private:
    struct Node
    {
      ItemType item;    // item
      Node     *next;   // pointer pointing to next item
    };

Node *frontNode;    // point to the first item
Node *backNode; // point to the first item


  public:
    // constructor
    Queue();
    //destructor
    ~Queue();


    // check if the queue is empty
    bool isEmpty();

    // enqueue item at the back of queue
    bool enqueue(ItemType& newItem);

    // dequeue item from front of queue
    bool dequeue();

          // dequeue and retrieve item from front of queue
    bool dequeue(ItemType& item);


    // retrieve item from front of queue
    void getFront(ItemType& item); 





};

Queue.cpp

/** @file Queue.cpp */

#include <cstddef>   // for NULL
#include <iostream>
#include <new>       // for bad_alloc
#include "Queue.h"  // header file

using namespace std;

Queue::Queue()
{
    backNode = NULL;
    frontNode = NULL;
}  // end default constructor


Queue::~Queue()
{
   while (!isEmpty())
      dequeue();
}  // end destructor

bool Queue::isEmpty()
{
   return backNode == NULL;
}  // end isEmpty

bool Queue::enqueue(ItemType& item)
{
     // create a new node
      Node *newNode = new Node;
      newNode->item = item;
      newNode->next = NULL;

      // insert the new node
      if (isEmpty())
     // insertion into empty queue
         frontNode = newNode;
      else
     // insertion into nonempty queue
         backNode->next = newNode;

      backNode = newNode;  // new node is at back
      return true;
}  // end enqueue

bool Queue::dequeue() 
{
   if(!isEmpty())
   {  // queue is not empty; remove front
      Node *temp = frontNode;
      if (frontNode == backNode)   // special case?
      {  // yes, one node in queue
         frontNode = NULL;
         backNode = NULL;
      }
      else
         frontNode = frontNode->next;

      temp->next = NULL;  
      delete temp;
      temp = NULL;
      return true;
   }  // end if
   else 
   {
       cout << "empty queue, cannot dequeue" << endl;
       return false;
   }

}  // end dequeue

bool Queue::dequeue(ItemType& item)
{
   if (!isEmpty())
   {  // queue is not empty; retrieve front
      item = frontNode->item;
      dequeue();  // delete front
      return true;
   }  // end if
   else 
   {
       cout << "empty queue, cannot dequeue" << endl;
       return false;
   }

}  // end dequeue

void Queue::getFront(ItemType& item)
{
   if (!isEmpty())
      // queue is not empty; retrieve front
      item = frontNode->item;
    else 
        cout << "empty queue, cannot getFront" << endl;
}  // end getFront

// End of implementation file.

Answer 1

您需要将作业视为事件驱动系统一个队列将包含需要处理的事件。

如果我们有这样的事件类：

struct Event  
{  
  virtual bool  execute_if_time(const Time& t) = 0;
};

我们可以有一个vector指向事件的指针：

typedef std::vector< boost::smart_ptr<Event> > Event_Container;
Event_Container events;

会有一个调度程序循环：

while (1)
{
  Time t = now();
  for (Event_Container::iterator iter = events.begin();
       iter != events.end();
       ++it)
  {
     (*iter)->exeute_if_time(t);
  }
  sleep(/* some duration */)
}

调度程序将定期执行容器中的事件。

注意：这只是一个方案，因为还有很多其他方案就足够了。

剩下的代码留给读者练习。

C ++控制台应用程序;牙科诊所情况下的时间优化队列

1 个答案: