C++ CODE As you may recall, the implementation of the cs20::Queue< Object > data
ID: 3847029 • Letter: C
Question
C++ CODE
As you may recall, the implementation of the cs20::Queue< Object > data structure presented in class used a linked node structure with an identified front and back node. Based on this data structure, write the following method:
template
bool Queue::separatedBy( Object a, Object b, int amount ) const;
This method should determine whether the Queue has the two specified object arguments separated by the desired amount of QueueNodes. Feel free to define any public or private methods or members on the class Queueas you need. Please work with the code from class.
For example, please consider the queue shown below:
separatedBy( 8, 20, 1 ) should return false because 8 and 20 are not found on the queue.
separatedBy( 12, 20, 1 ) should return false because 20 is not found on the queue.
separatedBy( 12, 1, 1 ) should return false because 12 and 1 are not separated by 1 QueueNode on the queue.
separatedBy( 12, 1, 3 ) should return true because 12 and 1 are separated by 3 QueueNodes (namely, 5, 7, and 13) on the queue.
code is provided here
https://dropfile.to/QevBJfK access key; 2vs7ny6
https://dropfile.to/W7VaG8c access key: FaQ5K9G
////////////////////////////// CODE//////////////////////////////
//////////////////QueueMenu.cpp//////////////////////////////////////////////
#include
#include "Queue.h"
#include "EmptyQueue.h"
#include "QueueNode.h"
#include "Queue.cpp"
#include "QueueNode.cpp"
using namespace std;
using namespace cs20;
enum CHOICE {MAKEEMPTY, ENQUEUE, ISEMPTY, DEQUEUE, GETFRONT, QUIT, PRINT };
CHOICE menu();
int main(int argc, char* argv[]) {
int value;
Queue q;
CHOICE choice;
do {
choice = menu();
switch( choice ) {
case MAKEEMPTY:
q.makeEmpty();
break;
case ISEMPTY:
if (q.isEmpty()) {
cout << "queue is empty" << endl;
}
else {
cout << "queue is not empty" << endl;
}
break;
case DEQUEUE:
try {
value = q.dequeue();
cout << "Here's the value dequeued: ";
cout << value << endl;
} catch( EmptyQueue eq ) {
cout << "You silly... don't try dequeueing an empty queue!" << endl;
}
break;
case GETFRONT:
try {
value = q.getFront();
cout << "Here's the value returned from getFront: ";
cout << value << endl;
} catch( EmptyQueue eq ) {
cout << "You silly... don't try gettingFront an empty queue!" << endl;
}
break;
case ENQUEUE:
cout << "Please provide int to enqueue: ";
cin >> value;
q.enqueue( value );
break;
case PRINT:
q.printQueue( cout );
cout << endl;
break;
case QUIT:
break;
}
} while (choice != QUIT);
return( 0 );
}
CHOICE menu() {
char choice;
CHOICE result;
cout << "(M)akeEmpty I(s)Empty (E)nqueue (D)equeue (G)etFront (P)rint (Q)uit: " << endl;
cin >> choice;
switch( choice ) {
case 'E':
case 'e':
result = ENQUEUE;
break;
case 'M':
case 'm':
result = MAKEEMPTY;
break;
case 'S':
case 's':
result = ISEMPTY;
break;
case 'D':
case 'd':
result = DEQUEUE;
break;
case 'G':
case 'g':
result = GETFRONT;
break;
case 'Q':
case 'q':
result = QUIT;
break;
case 'P':
case 'p':
result = PRINT;
break;
}
return( result );
}
void sample() {
Queue q1;
Queue q2;
cout << "making q1" << endl;
q1.enqueue( 1 );
q1.enqueue( 2 );
cout << "print q1" << endl;
q1.printQueue( cout );
cout << endl;
cout << "q2 = q1" << endl;
q2 = q1;
cout << "print q2" << endl;
q2.printQueue( cout );
cout << endl;
q1.dequeue();
cout << "dequeue q1" << endl;
cout << "print q2" << endl;
q2.printQueue( cout );
cout << endl;
cout << "print q1" << endl;
q1.printQueue( cout );
cout << endl;
}
//////////////////Queue.h////////////////////////////////////////////////////////////////////////////////////////
#ifndef QUEUE_H
#define QUEUE_H
#include
#include "QueueNode.h"
#include "EmptyQueue.h"
namespace cs20 {
template
class Queue {
public:
Queue();
Queue( const Queue& rhs );
~Queue();
bool isEmpty() const;
void makeEmpty();
void enqueue( const Object& data );
const Object dequeue();
const Object& getFront() const;
const Queue& operator =( const Queue& rhs );
std::ostream& printQueue( std::ostream& outs );
private:
QueueNode* frontNode;
QueueNode* backNode;
};
}
#endif
//////////////////Queue.cpp////////////////////////////////////////////////////////////////////////////////////////
#ifndef QUEUE_CPP
#define QUEUE_CPP
#include "Queue.h"
namespace cs20 {
template
Queue::Queue() {
frontNode = nullptr;
backNode = nullptr;
}
template
Queue::Queue( const Queue& rhs ) {
frontNode = nullptr;
backNode = nullptr;
*this = rhs;
}
template
Queue::~Queue() {
makeEmpty();
// when empty, frontNode and backNode will already be null
}
template
bool Queue::isEmpty() const {
return( (frontNode == nullptr) );
}
template
void Queue::makeEmpty() {
while (!isEmpty()) {
dequeue();
}
}
template
void Queue::enqueue( const Object& data ) {
QueueNode* newNode = new QueueNode( data );
if (isEmpty()) {
frontNode = newNode;
backNode = newNode;
}
else {
backNode->setNext( newNode );
backNode = backNode->getNext();
}
}
template
const Object Queue::dequeue() {
Object frontData = getFront();
QueueNode* oldFront = frontNode;
frontNode = frontNode->getNext();
delete oldFront;
return( frontData );
}
template
const Object& Queue::getFront() const {
if (isEmpty()) {
throw EmptyQueue();
}
return( frontNode->getElement() );
}
// Deep copy of linked Queue
template
const Queue& Queue::operator =( const Queue& rhs ) {
if (this != &rhs) {
makeEmpty();
QueueNode* rhsFrontNode = rhs.frontNode;
while( rhsFrontNode != nullptr) {
enqueue( rhsFrontNode->getElement() );
rhsFrontNode = rhsFrontNode->getNext();
}
}
return( *this );
}
template
std::ostream& Queue::printQueue( std::ostream& outs ) {
if (isEmpty()) {
outs << "Empty Queue";
}
else {
outs << "FRONT: ";
QueueNode* node = frontNode;
while( node != nullptr) {
outs << node->getElement();
outs << " ";
node = node->getNext();
}
outs << ":BACK";
}
return( outs );
}
}
#endif
//////////////////QueueNode.h////////////////////////////////////////////////////////////////////////////////////////
#ifndef QUEUENODE_H
#define QUEUENODE_H
#include
namespace cs20 {
template
class QueueNode {
public:
QueueNode( const Object& theElement = Object(), QueueNode * node = nullptr );
// these accessors and mutators are called
// from Queue class
// no public methods expose QueueNode instances
// outside the Queue class
const Object& getElement() const;
QueueNode* getNext() const;
void setNext( QueueNode * node );
private:
Object element;
QueueNode* next;
};
}
#endif
//////////////////QueueNode.cpp////////////////////////////////////////////////////////////////////////////////////////
#ifndef QUEUENODE_CPP
#define QUEUENODE_CPP
#include "QueueNode.h"
namespace cs20 {
template
QueueNode::QueueNode( const Object& theElement,
QueueNode* node ) {
element = theElement;
next = node;
}
template
const Object& QueueNode::getElement() const {
return( element );
}
template
QueueNode* QueueNode::getNext() const {
return( next );
}
template
void QueueNode::setNext( QueueNode* node ) {
next = node;
}
}
#endif
//////////////////EmptyQueue.h////////////////////////////////////////////////////////////////////////////////////////
#ifndef EMPTYQUEUE_H
#define EMPTYQUEUE_H
#include
#include
namespace cs20 {
class EmptyQueue : public std::logic_error {
public:
EmptyQueue( const std::string& msg = "" );
};
}
#endif
//////////////////EmptyQueue.cpp////////////////////////////////////////////////////////////////////////////////////////
#include "EmptyQueue.h"
namespace cs20 {
EmptyQueue::EmptyQueue( const std::string& msg ) : std::logic_error( msg.c_str() ) {}
}
Explanation / Answer
struct THENODE { char Name[20]; THENODE *Link; }; class Queue { THENODE *front,*rear; public: Queue( ) { front = rear = NULL; } void Insert( ); void Delete( ); void Display( ); }; void Queue::Insert( ) { THENODE *ptr; ptr=new THENODE; if(ptr= = NULL) { cout<<” No memory to create a new node….”; exit(1); } cout<<” Enter the name….”; gets(ptrName); ptrLink=NULL; if(rear= = NULL) front=rear=ptr; else { rearLink=ptr; rear=ptr; } } 3.e) Evaluate the following postfix
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.