New Topic/Question
Reply
header file
//Header file QueueAsArray
#ifndef _NODE_
#define _NODE_
template <class Type>
struct Node // struct for storing some item
{ // in a linked list
Type item;
Node<Type> * next;
};
#endif
#ifndef H_linkedQueue
#define H_linkedQueue
#include <iostream>
#include <cassert>
using namespace std;
template <class Type>
class linkedQueueType
{
public:
const linkedQueueType<Type>& operator=(const linkedQueueType<Type>&);
// overload the assignment operator
void initializeQueue();
bool isEmptyQueue();
void queueCount();
Type front() const;
Type back() const;
void clearFront();
void addQueue(Type queueElement);
void deleteQueue();
linkedQueueType();
linkedQueueType(const linkedQueueType<Type>& otherQueue); // copy constructor
~linkedQueueType(); //destructor
private:
Node<Type> *lastElem;
Node<Type> *queueFront;
Node<Type> *queueRear;
int count;
Node<Type> * CopyList(const Node<Type> * ptr) const;
};
template <class Type>
void linkedQueueType<Type>::clearFront()
{
delete queueFront;
}
template<class Type>
void linkedQueueType<Type>::queueCount()
{
return count;
}
template<class Type>
void linkedQueueType<Type>::initializeQueue()
{
count = 0;
queueFront->next = queueRear;
queueRear->next = queueFront;
}
template<class Type>
bool linkedQueueType<Type>::isEmptyQueue()
{
if(count == 0)
{
return true;
}
return false;
}
template<class Type>
void linkedQueueType<Type>::addQueue(Type newElement)
{
if(isEmptyQueue())
{
queueFront->next = lastElem;
lastElem->next = queueRear;
lastElem->item = newElement;
}
else
{
queueRear->next = new Node( item ); //creating the link
queueRear = queueRear->next; //updating the last element
}
count++;
}
template<class Type>
void linkedQueueType<Type>::deleteQueue()
{
if(!isEmptyQueue())
{
Node *currNode = queueFront->next;
for(int i = 0; i < count; i++)
{
currNode->item = 0;
currNode = currNode->next;
}
count = 0;
}
}
template<class Type>
Type linkedQueueType<Type>::front() const
{
assert(!isEmptyQueue());
return (queueFront->next->item);
}
template<class Type>
Type linkedQueueType<Type>::back() const
{
assert(!isEmptyQueue());
return (lastElem->item);
}
template<class Type>
const linkedQueueType<Type>& linkedQueueType<Type>::operator=(const linkedQueueType<Type>& otherQueue)
{
if (this != &otherQueue) //avoid self-copy
{
while(!IsEmpty())
{
clearFront();
}
if (otherQueue.queueFront == NULL)
{
queueFront = NULL;
queueRear = NULL;
}
else
{
queueFront = CopyList(otherQueue.queueFront);
queueRear = queueFront;
while (queueRear->next != NULL)
{
queueRear = queueRear->next;
}
}
}
return *this;
}
template <class Type>
Node<Type> * linkedQueueType<Type>::CopyList(const Node<Type> * ptr) const
{
if (ptr == NULL)
{
return NULL;
}
else {
Node<Type> * temp = new Node<Type>;
temp->item = ptr->item;
temp->next = CopyList(ptr->next);
return temp;
}
}
template<class Type>
linkedQueueType<Type>::linkedQueueType(const linkedQueueType<Type>& otherQueue)
{
if(otherQueue.queueFront == NULL)
{
queueFront = NULL;
queueRear = NULL;
}
else
{
queueFront = CopyList(otherQueue.queueFront);
queueRear = queueFront;
}
while (queueRear->next != NULL)
{
queueRear = queueRear->next;
}
}
#endif
main file
#include <iostream>
#include "linkedQueue.h"
using namespace std;
int size = 1000;
int main()
{
linkedQueueType<int> queue1, queue2;
int x, y;
x = 4;
y = 5;
queue1.addQueue(x);
queue1.addQueue(y);
x = queue1.front();
queue1.deleteQueue();
queue1.addQueue(x + 5);
queue1.addQueue(16);
queue1.addQueue(x);
queue1.addQueue(y - 3);
queue1.addQueue(23);
cout << "queue1 size is equal to " << queue1.queueCount << endl;
cout << "queue2 size is equal to " << queue2.queueCount << endl;
queue2 = queue1;
cout << "new queue1 size is equal to " << queue1.queueCount << endl;
cout << "new queue2 size is equal to " << queue2.queueCount << endl;
while (!queue1.isEmptyQueue())
{
cout << queue1.front() << " ";
queue1.deleteQueue();
}
cout << endl;
cout << "queue2: ";
while (!queue2.isEmptyQueue())
{
cout << queue2.front() << " ";
queue2.deleteQueue();
}
cout << endl;
return 0;
}
MultiQuote
| 