- Implement array based queue ( 50 pts ) - Implement linked-list based queue ( 5
ID: 3724964 • Letter: #
Question
- Implement array based queue (50 pts)
- Implement linked-list based queue (50 pts)
In either of which,
- enqueue(): (15 pts)
- dequeue(): (15 pts)
- Others (constructor, destructor, clear(), isEmpty(), isFull()):
(20 pts)
QueueLinked.h
// QueueLinked.h
#include <stdexcept>
#include <iostream>
using namespace std;
#include "Queue.h"
template <typename DataType>
class QueueLinked : public Queue<DataType> {
public:
QueueLinked(int maxNumber = Queue<DataType>::MAX_QUEUE_SIZE);
QueueLinked(const QueueLinked& other);
QueueLinked& operator=(const QueueLinked& other);
~QueueLinked();
void enqueue(const DataType& newDataItem) throw (logic_error);
DataType dequeue() throw (logic_error);
void clear();
bool isEmpty() const;
bool isFull() const;
// Programming Exercise 2
void putFront(const DataType& newDataItem) throw (logic_error);
DataType getRear() throw (logic_error);
// Programming Exercise 3
int getLength() const;
void showStructure() const;
private:
class QueueNode {
public:
QueueNode(const DataType& nodeData, QueueNode* nextPtr);
DataType dataItem;
QueueNode* next;
};
QueueNode* front;
QueueNode* back;
};
QueueLinked.cpp
#include "QueueLinked.h"
template <typename DataType>
QueueLinked<DataType>::QueueNode::QueueNode(const DataType& nodeData, QueueNode* nextPtr)
{
}
template <typename DataType>
QueueLinked<DataType>::QueueLinked(int maxNumber = Queue<DataType>::MAX_QUEUE_SIZE)
{
}
template <typename DataType>
QueueLinked<DataType>::QueueLinked(const QueueLinked& other)
{
}
template <typename DataType>
QueueLinked<DataType>& QueueLinked<DataType>::operator=(const QueueLinked& other)
{
}
template <typename DataType>
QueueLinked<DataType>::~QueueLinked()
{
}
template <typename DataType>
void QueueLinked<DataType>::enqueue(const DataType& newDataItem) throw (logic_error)
{
}
template <typename DataType>
DataType QueueLinked<DataType>::dequeue() throw (logic_error)
{
DataType temp;
return temp;
}
template <typename DataType>
void QueueLinked<DataType>::clear()
{
}
template <typename DataType>
bool QueueLinked<DataType>::isEmpty() const
{
return false;
}
template <typename DataType>
bool QueueLinked<DataType>::isFull() const
{
return false;
}
template <typename DataType>
void QueueLinked<DataType>::putFront(const DataType& newDataItem) throw (logic_error)
{
}
template <typename DataType>
DataType QueueLinked<DataType>::getRear() throw (logic_error)
{
DataType temp;
return temp;
}
template <typename DataType>
int QueueLinked<DataType>::getLength() const
{
}
template <typename DataType>
void QueueLinked<DataType>::showStructure() const
{
QueueNode *p; // Iterates through the queue
if ( isEmpty() )
cout << "Empty queue" << endl;
else
{
cout << "Front ";
for ( p = front ; p != 0 ; p = p->next )
{
if( p == front )
{
cout << '[' << p->dataItem << "] ";
}
else
{
cout << p->dataItem << " ";
}
}
cout << " rear" << endl;
}
}
Explanation / Answer
Please find my implementation using Array.
Please repost for Linked List Implementation.
template <class QueueItem> class Queue {
private:
QueueItem buffer[100];
int head, tail, count;
public:
Queue();
void enqueue(QueueItem item);
QueueItem dequeue();
int Size();
bool isFull();
bool isEmpty();
~Queue();
};
template <class QueueItem>
Queue<QueueItem>::Queue() : count(0), head(0), tail(0) {}
template <class QueueItem>
void Queue<QueueItem>::enqueue(QueueItem item) {
assert(count <100);
buffer[tail] = item;
tail = (tail + 1)% 100;
count++;
}
template <class QueueItem>
QueueItem Queue<QueueItem>::dequeue() {
assert(count > 0);
int val = head;
head = (head + 1)%100;
count--;
return buffer[val];
}
template <class QueueItem>
bool Queue<QueueItem>::isFull() { return count==100; }
template <class QueueItem>
bool Queue<QueueItem>::isEmpty() { return count==0; }
template <class QueueItem>
int Queue<QueueItem>::Size() { return count; }
template <class QueueItem>
Queue<QueueItem>::~Queue() {}
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.