C++ console application; time optimised queue in a dental clinic situation - c++

Question

I'm trying to solve a queue problem that is required in my assignment.
The details are as follows :
- I am asked to create an automate robust queuing sub-system (note that the each dental clinic has 2 doctors and 4 dentist chairs, 1 x-ray machine on its premise)
- Time-optimised algorithm (different type of treatment). For example, tooth decay would require 30 minutes, checkup would be only 15 minutes, etc.
- Every clinic expected about ~20 and ~15 patients in the morning and afternoon per day respectively.
- The clinic timing is 8am – 12pm, 2pm – 6pm
Upon asking my lecturer, he said that I would need 2 queues(for each doctor), x-ray machines would be an instant process and requires no time at all and in the end of the day, when comparing these 2 queues, the difference of the total duration would be almost equal.
I have been trying to solve this problem but to no avail. Can someone explain how these would be solved?
EDIT :
I have created the queue implementation and a Visit class that is supposed to be enqueued into the queue. What I need to figure out is the algorithm on how to schedule all these visits such that the queues will be time-efficient.
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

You need to think of the assignment as an event driven system.
One queue would contain events that need to be handled.
If we have an event class like so:
struct Event
{
virtual bool execute_if_time(const Time& t) = 0;
};
We could have a vector of pointers to events:
typedef std::vector< boost::smart_ptr<Event> > Event_Container;
Event_Container events;
There would be a scheduler loop:
while (1)
{
Time t = now();
for (Event_Container::iterator iter = events.begin();
iter != events.end();
++it)
{
(*iter)->exeute_if_time(t);
}
sleep(/* some duration */)
}
The scheduler would execute events in the container at periodic intervals.
Note: this is only one scheme, as there are many others that would suffice.
The rest of the code is left as an exercise for the reader.