Question

Deques A deque (pronounced deck) is a double-ended queue. It is a data structure that supports insertion and removal at both its front and its back, but not at any other position. It combines and extends the operations of both a stack (insert at the front and remove from the front) and a queue (insert at the back, remove from the front). There are a number of possible implementations of a deque; you are to implement this data structure using a doubly linked list. This allows all insertion and removal operations to be performed in constant time. Doubly Linked Lists Nodes in a doubly linked list have two pointers instead of one. One pointer points to the next node in the list, the other to the previous node. The previous pointer at the head of the list and the next pointer at the tail of the list are both set to nullptr. The structure allows the list to be traversed from the head to the tail or from the tail to the head. For your deque implementation this allows removeBack to be implemented in constant time. Here is a sketch of a the nodes in a Deque's list that contains the values 3, 4, 5 and 6. nullptr <-|3|-> <-14|-> <-15|-> <-16|-> nullptr The linked list object would contain two Node pointers, one that points to the head of the list (containing 3) and another that points to its tail (containing 6). Deque Public Methods You must implement a Deque template class to store data of any type. This class must be implemented using a doubly linked list of Nodes, where Node is a class that you also implement. Note that the insertion and removal methods (insertFront, insertBack, removeFront, removeBack) should all be implemented in constant time. The Deque class should implement the following public methods: • constructor - creates an empty Deque • copy constructor - a constructor that creates a deep copy of its constant Deque reference parameter • destructor - deallocates dynamic memory allocated by the Deque • operator=- overloads the assignment operator for Deque - (deep) copies its constant Deque reference parameter into the calling object and returns a reference to the calling object after de-allocating any dynamic memory associated with the original contents of the calling object; if the calling object is the same as the parameter the operator should not copy it .insertFront - inserts its template parameter at the front of the Deque .insertBack - inserts its template parameter at the back of the Deque • removeFront - removes and returns the value at the front of the Deque; if the Deque is empty throws a runtime_error (this error class is defined in the stdexcept library file) • removeBack - removes and returns the value at the back of the Deque; if theDeque is empty throws a runtime_error • peekFront - returns the value at the front of the Deque without removing it; if the Deque is empty throws a runtime_error . peekBack - returns the value at the back of the Deque without removing it; if the Deque is empty throws a runtime_error • empty-returns true if the Deque is empty, false otherwise • size - returns the number of items stored in the Deque, as an int

Simple test in text:

int main()
{
       Deque dq1;
       cout << dq1.empty() << " - 1" << endl;
       dq1.insertFront(42);
       dq1.insertBack(216);
       cout << dq1.peekFront() << " - 42" << endl;
       cout << dq1.peekBack() << " - 216" << endl;
       cout << dq1.size() << " - 2" << endl;

       Deque dq2(dq1);
       Deque dq3;
       dq3 = dq1;

       cout << dq1.removeFront() << " - 42" << endl;
       cout << dq1.removeBack() << " - 216" << endl;

       cout << dq2.peekFront() << " - 42" << endl;
       cout << dq2.peekBack() << " - 216" << endl;
       cout << dq3.peekFront() << " - 42" << endl;
       cout << dq3.peekBack() << " - 216" << endl;
       return 0;
}

C++ Question

Answer 1

#include <bits/stdc++.h>
using namespace std;

struct Node {
int data;
Node *next, *prev;
public:
Node(int val){
data = val;
next=nullptr;
prev=nullptr;
}

friend class Deque;
};

class Deque{
Node *front;
Node *rear;
public:
Deque();
Deque(Deque &copy);
~Deque();
void operator = (Deque &copy);
void insertFront(int val);
void insertBack(int val);
int removeFront();
int removeBack();
int peekFront();
int peekBack();
bool empty();
int size();

};

Deque::Deque(){
front=nullptr;
rear=nullptr;
}

Deque::Deque(Deque &copy){
Node* curr=copy.front;
if(curr==nullptr)
return;
front = new Node(curr->data);
Node *temp = front;
//curr=curr->next;
while(curr->next!=nullptr){
temp->next = new Node(curr->next->data);
temp->next->prev = temp;
curr = curr->next;
temp = temp->next;
}
rear = temp;
}

Deque::~Deque(){
Node *temp=front;
front=nullptr;
Node *temp2;
while(temp!=nullptr){
temp2=temp;
temp=temp->next;
delete(temp2);
}
rear = nullptr;
}

void Deque::operator=(Deque &copy){
//check doubly linked list is same
Node *curr=copy.front;
Node *temp = front;
while(temp!= nullptr && curr!=nullptr)
{
if(temp->data==curr->data){
temp = temp->next;
curr = curr->next;
}else{
break;
}
}
if(temp==nullptr && curr==nullptr){
return;
}
//free the doubly linked list
temp=front;
front=nullptr;
Node *temp2;
while(temp!=nullptr){
temp2=temp;
temp=temp->next;
delete(temp2);
}
rear = nullptr;
//original list is now empty
curr=copy.front;
front = new Node(curr->data);
temp = front;
//curr=curr->next;
while(curr->next!=nullptr){
temp->next = new Node(curr->next->data);
temp->next->prev = temp;
curr = curr->next;
temp = temp->next;
}
rear = temp;

}

void Deque::insertFront(int val){
if(front==nullptr){
front=new Node(val);
rear=front;
return;
}
Node *temp = new Node(val);
temp->next=front;
front->prev=temp;
front=temp;
}

void Deque::insertBack(int val){
if(front==nullptr){
front=new Node(val);
rear=front;
return;
}
Node *temp = new Node(val);
rear->next=temp;
temp->prev = rear;
rear=temp;

}

int Deque::removeFront()
{
if(front==nullptr){
throw "Your list an empty";
}
Node *temp=front;
front=front->next;
int num = temp->data;
if(front!=nullptr)
front->prev=nullptr;
delete(temp);
return num;
}
int Deque::removeBack()
{
if(rear==nullptr){
throw "Your list an empty";
}
Node *temp = rear;
int num = temp->data;
rear = rear->prev;
if(rear!=nullptr)
rear->next=nullptr;
delete(temp);
return num;

}

int Deque::peekFront()
{
if(front==nullptr){
throw "Your list an empty";
}
return front->data;
}

bool Deque::empty()
{
if(front==nullptr)
return true;
return false;
}
int Deque::size()
{
Node *temp=front;
int count=0;
while(temp!=nullptr)
{
count++;
temp=temp->next;
}
return count;

}

int Deque::peekBack()
{
if(front==nullptr){
throw "Your list an empty";
}
return rear->data;

}

int main() {
Deque dq1;
cout << dq1.empty() << " - 1" << endl;
dq1.insertFront(42);
dq1.insertBack(216);
cout << dq1.peekFront() << " - 42" << endl;
cout << dq1.peekBack() << " - 216" << endl;
cout << dq1.size() << " - 2" << endl;
Deque dq2(dq1);
Deque dq3;
dq3 = dq1;
cout << dq1.removeFront() << " - 42" << endl;
cout << dq1.removeBack() << " - 216" << endl;
cout << dq2.peekFront() << " - 42" << endl;
cout << dq2.peekBack() << " - 216" << endl;
cout << dq3.peekFront() << " - 42" << endl;
cout << dq3.peekBack() << " - 216" << endl;
return 0;
}

Output:

1 D:\program\deletebothend.exe 1 1 42 42 216 216 2 - 2 42 42 216 216 42 42 216 216 42 42 216 216 execution time : 0.162 s Process returned o (Oxo) Press any key to continue.