1.
Implement methods add, size in template class DLinkedList
(which implements List ADT) representing the doubly linked list
with type T with the initialized frame. The description of each
method is given in the code.
template <class T>
class DLinkedList {
public:
class Node; // Forward declaration
protected:
Node* head;
Node* tail;
int count;
public:
DLinkedList();
~DLinkedList();
void add(const T &e);
void add(int index, const T &e);
int size();
public:
class Node
private:
T data;
Node *next;
Node *previous;
friend class DLinkedList<T>;
public:
Node()
this->previous = NULL;
this->next = NULL;
Node(const T &data)
this->data = data;
this->previous = NULL;
this->next = NULL;
};
};
In this exercise, we have include <iostream>, <string>, <sstream> and using namespace std.
For example:
Test Result
DLinkedList<int> list; [0,1,2,3,4,5,6,7,8,9]
int size = 10;
for(int idx=0; idx < size; idx++)
{
list.add(idx);
}
cout << list.toString();
DLinkedList<int> list; [9,8,7,6,5,4,3,2,1,0]
int size = 10;
for(int idx=0; idx < size; idx++)
{
list.add(0, idx);
}
cout << list.toString();
template <class T>
void DLinkedList<T>::add(const T& e) {
/* Insert an element into the end of the list. */
Node* newNode = new Node(e);
if (head == NULL){
head = newNode;
tail = newNode;
count++;
}
else{
tail->next = newNode;
newNode->previous = tail;
tail = tail->next;
count++;
}
}
template<class T>
void DLinkedList<T>::add(int index, const T& e) {
/* Insert an element into the list at given index. */
if (index < 0 || index > count)
throw std::out_of_range("Out of range");
Node* newNode = new Node(e);
if (head == NULL){
head = newNode;
tail = newNode;
count++;
return;
}
Node* cur = head;
Node* pre = NULL;
for (int i = 0; i < index; i++){
pre = cur;
cur = cur->next;
}
if (pre == NULL){
newNode->next = cur;
cur->previous = newNode;
head = newNode;
}
else{
newNode->next = cur;
pre->next = newNode;
newNode->previous = pre;
if (cur == NULL)
tail = newNode;
else
cur->previous = newNode;
}
count++;
}
template<class T>
int DLinkedList<T>::size() {
/* Return the length (size) of list */
return this->count;
}
Test Expected Got
DLinkedList<int> list; [0,1,2,3,4,5,6,7,8,9] [0,1,2,3,4,5,6,7,8,9
int size = 10; ]
for(int idx=0; idx < size; idx++){
list.add(idx);
}
cout << list.toString();
DLinkedList<int> list; [9,8,7,6,5,4,3,2,1,0] [9,8,7,6,5,4,3,2,1,0
int size = 10; ]
for(int idx=0; idx < size; idx++){
list.add(0, idx);
}
cout << list.toString();
Passed all tests!
2. Implement methods get, set, empty, indexOf, contains in
template class DLinkedList (which implements List
ADT) representing the singly linked list with type T with the
initialized frame. The description of each method is given in the
code.
template <class T>
class DLinkedList {
public:
class Node; // Forward declaration
protected:
Node* head;
Node* tail;
int count;
public:
DLinkedList();
~DLinkedList();
void add(const T &e);
void add(int index, const T &e);
int size();
bool empty();
T get(int index);
void set(int index, const T &e);
int indexOf(const T &item);
bool contains(const T &item);
public:
class Node
private:
T data;
Node *next;
Node *previous;
friend class DLinkedList<T>;
public:
Node()
this->previous = NULL;
this->next = NULL;
}
Node(const T &data)
this->data = data;
this->previous = NULL;
this->next = NULL;
};
};
In this exercise, we have include <iostream>, <string>, <sstream> and using
namespace std.
For example:
Test Result
DLinkedList<int> list; 0 |1 |2 |3 |4 |5 |6 |7 |8 |9
int size = 10; |
for(int idx=0; idx < size; idx++){
list.add(idx);
}
for(int idx=0; idx < size; idx++){
cout << list.get(idx) << " |";
}
DLinkedList<int> list; [2,5,6,3,67,332,43,1,0,9]
int size = 10;
int value[] =
{2,5,6,3,67,332,43,1,0,9};
for(int idx=0; idx < size; idx++){
list.add(idx);
}
for(int idx=0; idx < size; idx++){
list.set(idx, value[idx]);
}
cout << list.toString();
template<class T>
T DLinkedList<T>::get(int index) {
/* Give the data of the element at given index in the list. */
Node* travel = this->head;
if(travel==NULL) return travel->data;
if(index==0) return travel->data;
int place=0;
while(travel->next!=NULL && place!=index)
{
place++;
travel=travel->next;
}
return travel->data;
}
template <class T>
void DLinkedList<T>::set(int index, const T& e) {
/* Assign new value for element at given index in the list */
Node* travel = this->head;
if(travel==NULL) return;
if(index==0) {travel->data=e; return;}
int place=0;
while(travel->next!=NULL && place!=index)
{
place++;
travel=travel->next;
}
travel->data=e;
return;
}
template<class T>
bool DLinkedList<T>::empty() {
/* Check if the list is empty or not. */
Node* travel = this->head;
if(travel==NULL) return true;
return false;
template<class T>
int DLinkedList<T>::indexOf(const T& item) {
/* Return the first index wheter item appears in list, otherwise return -1 */
Node* travel = this->head;
if(travel==NULL) return -1;
if(travel->data==item) return 0;
int place=0;
while(travel!=NULL && travel->data!=item)
{
place++;
travel=travel->next;
}
if(travel==NULL) return -1;
return place;
}
template<class T>
bool DLinkedList<T>::contains(const T& item) {
/* Check if item appears in the list */
Node* travel = this->head;
if(travel==NULL) return false;
if(travel->data==item) return true;
while(travel!=NULL && travel->data!=item)
{
travel=travel->next;
}
if(travel!=NULL) return true;
return false;
}
Test Expected Got
DLinkedList<int> list; 0 |1 |2 |3 |4 |5 |6 |7 |8 |9 | 0 |1 |2 |3 |4 |5 |6 |7 |8 |9 |
int size = 10;
for(int idx=0; idx < size; idx++){
list.add(idx);
}
for(int idx=0; idx < size; idx++){
cout << list.get(idx) << " |";
}
DLinkedList<int> list; [2,5,6,3,67,332,43,1,0,9] [2,5,6,3,67,332,43,1,0,9]
int size = 10;
int value[] = {2,5,6,3,67,332,43,1,0,9};
for(int idx=0; idx < size; idx++){
list.add(idx);
}
for(int idx=0; idx < size; idx++){
list.set(idx, value[idx]);
}
cout << list.toString();
Passed all tests!
3. Implement methods removeAt, removeItem, clear in template
class SLinkedList (which implements List ADT) representing the
singly linked list with type T with the initialized frame. The
description of each method is given in the code.
template <class T>
class DLinkedList {
public:
class Node; // Forward declaration
protected:
Node* head;
Node* tail;
int count;
public:
DLinkedList();
~DLinkedList();
void add(const T &e);
void add(int index, const T &e);
int size();
bool empty();
T get(int index);
void set(int index, const T &e);
int indexOf(const T &item);
bool contains(const T &item);
T removeAt(int index);
bool removeItem(const T &item);
void clear();
public:
class Node
private:
T data;
Node *next;
Node *previous;
friend class DLinkedList<T>;
public:
Node()
this->previous = NULL;
this->next = NULL;
Node(const T &data)
this->data = data;
this->previous = NULL;
this->next = NULL;
};
};
In this exercise, we have include <iostream>, <string>, <sstream> and using
namespace std.
For example:
Test Result
DLinkedList<int> list; [5,6,3,67,332,43,1,0,9]
int size = 10;
int value[] = {2,5,6,3,67,332,43,1,0,9};
for(int idx=0; idx < size; idx++){
list.add(value[idx]);
}
list.removeAt(0);
cout << list.toString();
template <class T>
T DLinkedList<T>::removeAt(int index)
{
/* Remove element at index and return removed value */
if (index < 0 || index >= count )
throw std::out_of_range("Out of range");
T val;
if (index == 0){
if (count == 1){
val = head->data;
delete head;
head = NULL;
tail = NULL;
}
else {
head->next->previous = NULL;
val = head->data;
Node* temp = head;
head = head->next;
delete temp;
}
}
else {
Node* pre = NULL;
Node* cur = head;
for (int i = 0; i < index; i++){
pre = cur;
cur = cur->next;
}
val = cur->data;
pre->next = cur->next;
if (cur->next == NULL)
tail = pre;
else
cur->next->previous = pre;
delete cur;
}
count--;
return val;
}
template <class T>
bool DLinkedList<T>::removeItem(const T& item)
{
/* Remove the first apperance of item in list and return true, otherwise return false */
int index = indexOf(item);
if (index != -1) {
removeAt(index);
return true;
}
else return false;
}
template<class T>
void DLinkedList<T>::clear(){
/* Remove all elements in list */
while (head != NULL) {
Node* temp = head;
head = head->next;
delete temp;
count--;
}
tail = NULL;
}
Test Expected Got
DLinkedList<int> list; [5,6,3,67,332,43,1,0,9] [5,6,3,67,332,43,1,0,9]
int size = 10;
int value[] = {2,5,6,3,67,332,43,1,0,9};
for(int idx=0; idx < size; idx++){
list.add(value[idx]);
}
list.removeAt(0);
cout << list.toString();
Passed all tests!
4. Implement all methods in class Stack with template type T. The description of each method is written as
comment in frame code.
#ifndef STACK_H
#define STACK_H
#include "DLinkedList.h"
template<class T>
class Stack {
protected:
DLinkedList<T> list;
public:
Stack() {}
void push(T item) ;
T pop() ;
T top() ;
bool empty() ;
int size() ;
void clear() ;
};
#endif
You can use all methods in class DLinkedList without implementing them again. The description of
class DLinkedList is written as comment in frame code.
template <class T>
class DLinkedList
{
public:
class Node; //forward declaration
protected:
Node* head;
Node* tail;
int count;
public:
DLinkedList() ;
~DLinkedList();
void add(const T& e);
void add(int index, const T& e);
T removeAt(int index);
bool removeItem(const T& removeItem);
bool empty();
int size();
void clear();
T get(int index);
void set(int index, const T& e);
int indexOf(const T& item);
bool contains(const T& item);
};
For example:
Test Result
Stack<int> stack; 1 0
cout << stack.empty() << " " << stack.size();
Stack<int> stack; 8
int item[] = { 3, 1, 4, 5, 2, 8, 10, 12 };
for (int idx = 0; idx < 8; idx++)
stack.push(item[idx]);
assert(stack.top() == 12);
stack.pop();
stack.pop();
cout << stack.top();
void push(T item) {
// TODO: Push new element into the top of the stack
DLinkedList<T> p = this->list;
this->list.add(item);
}
T pop() {
// TODO: Remove an element on top of the stack
int size = this->list.size()-1;
return this->list.removeAt(size);
}
T top() {
// TODO: Get value of the element on top of the stack
int size = this->list.size()-1;
T solution = this->list.get(size);
return solution;
}
bool empty() {
// TODO: Determine if the stack is empty
return this->list.empty();
}
int size() {
// TODO: Get the size of the stack
int size = this->list.size();
return size;
}
void clear() {
// TODO: Clear all elements of the stack
this->list.clear();
}
Go
Expected
Test t
Stack<int> stack;
1 0 1 0
cout << stack.empty() << " " << stack.size();
Stack<int> stack;
int item[] = { 3, 1, 4, 5, 2, 8, 10, 12 };
for (int idx = 0; idx < 8; idx++)
stack.push(item[idx]);
8 8
assert(stack.top() == 12);
stack.pop();
stack.pop();
cout << stack.top();
Passed all tests!
5. Implement all methods in class Queue with template type T. The description of each method is written as
comment in frame code.
#ifndef QUEUE_H
#define QUEUE_H
#include "DLinkedList.h"
template<class T>
class Queue {
protected:
DLinkedList<T> list;
public:
Queue() {}
void push(T item) ;
T pop() ;
T top() ;
bool empty() ;
int size() ;
void clear() ;
};
#endif /* QUEUE_H */
You can use all methods in class DLinkedList without implementing them again. The description of
class DLinkedList is written as comment in frame code.
template <class T>
class DLinkedList
{
public:
class Node; //forward declaration
protected:
Node* head;
Node* tail;
int count;
public:
DLinkedList() ;
~DLinkedList();
void add(const T& e);
void add(int index, const T& e);
T removeAt(int index);
bool removeItem(const T& removeItem);
bool empty();
int size();
void clear();
T get(int index);
void set(int index, const T& e);
int indexOf(const T& item);
bool contains(const T& item);
};
For example:
Test Result
Queue<int> queue;
assert(queue.empty());
assert(queue.size() ==
0);
void push(T item) {
// TODO: Push new element into the end of the queue
this->list.add(item);
}
T pop() {
// TODO: Remove an element in the head of the queue
return this->list.removeAt(0);
}
T top() {
// TODO: Get value of the element in the head of the queue
return this->list.get(0);
}
bool empty() {
// TODO: Determine if the queue is empty
return this->list.empty();
}
int size() {
// TODO: Get the size of the queue
return this->list.size();
}
void clear() {
// TODO: Clear all elements of the queue
this->list.clear();
}
Test
Passed all tests!
6. Implement method bubbleSort() in class SLinkedList to sort this list in ascending order. After each bubble, we
will print out a list to check (using printList).
#include <iostream>
#include <sstream>
using namespace std;
template <class T>
class SLinkedList {
public:
class Node; // Forward declaration
protected:
Node* head;
Node* tail;
int count;
public:
SLinkedList()
this->head = nullptr;
this->tail = nullptr;
this->count = 0;
~SLinkedList(){};
void add(T e)
Node *pNew = new Node(e);
if (this->count == 0)
this->head = this->tail = pNew;
}
else
this->tail->next = pNew;
this->tail = pNew;
this->count++;
int size()
return this->count;
void printList()
stringstream ss;
ss << "[";
Node *ptr = head;
while (ptr != tail)
ss << ptr->data << ",";
ptr = ptr->next;
if (count > 0)
ss << ptr->data << "]";
else
ss << "]";
cout << ss.str() << endl;
public:
class Node {
private:
T data;
Node* next;
friend class SLinkedList<T>;
public:
Node() {
next = 0;
Node(T data) {
this->data = data;
this->next = nullptr;
};
void bubbleSort();
};
For example:
Test Result
int arr[] = {9, 2, 8, 4, 1}; [2,8,4,1,9]
SLinkedList<int> list; [2,4,1,8,9]
for(int i = 0; i <int(sizeof(arr))/4;i+ [2,1,4,8,9]
+) [1,2,4,8,9]
list.add(arr[i]);
list.bubbleSort();
template <class T>
void SLinkedList<T>::bubbleSort()
{
for(int i = 0;i<this->count - 1; i++)
{
Node*c=this->head;
for(int j=i+1; j <this->count;j++)
{
if((c->data)>(c->next->data))
{
int temp = c->data;
c->data = c->next->data;
c->next->data = temp;
}
c=c->next;
}
this->printList();
}
}
Test Expected Got
int arr[] = {9, 2, 8, 4, 1}; [2,8,4,1,9] [2,8,4,1,9]
SLinkedList<int> list; [2,4,1,8,9] [2,4,1,8,9]
for(int i = 0; i <int(sizeof(arr))/4;i+ [2,1,4,8,9] [2,1,4,8,9]
+) [1,2,4,8,9] [1,2,4,8,9]
list.add(arr[i]);
list.bubbleSort();
Passed all tests!
7. Implement static method selectionSort in class Sorting to sort an array in
ascending order. After each selection, we will print out a list to check (using
printArray).
#include <iostream>
using namespace std;
template <class T>
class Sorting
public:
/* Function to print an array */
static void printArray(T *start, T *end)
int size = end - start;
for (int i = 0; i < size - 1; i++)
cout << start[i] << ", ";
cout << start[size - 1];
cout << endl;
}
static void selectionSort(T *start, T *end);
};
For example:
Test Result
int arr[] = {9, 2, 8, 1, 0, -2}; -2, 2, 8, 1, 0, 9
Sorting<int>::selectionSort(&arr[0], -2, 0, 8, 1, 2, 9
&arr[6]); -2, 0, 1, 8, 2, 9
-2, 0, 1, 2, 8, 9
-2, 0, 1, 2, 8, 9
template <class T>
void Sorting<T>::selectionSort(T *start, T *end)
{
int size = end - start;
for(int i = 0; i<size-1; i++)
{
int min=999;
int minPlace=i;
for(int j = i+1;j<size;j++)
{
if(min>start[j]) {min=start[j];minPlace=j;}
}
if(min<start[i]) {int temp = start[minPlace];
start[minPlace] = start[i];
start[i] = temp;
}
printArray(start,end);
}
}
Expected Got
Test
-2, 2, 8, 1, 0,
9
-2, 0, 8, 1, 2,
-2, 2, 8, 1, 0, 9
9
int arr[] = {9, 2, 8, 1, 0, -2}; -2, 0, 8, 1, 2, 9
-2, 0, 1, 8, 2,
Sorting<int>::selectionSort(&arr[0], -2, 0, 1, 8, 2, 9
9
&arr[6]); -2, 0, 1, 2, 8, 9
-2, 0, 1, 2, 8,
-2, 0, 1, 2, 8, 9
9
-2, 0, 1, 2, 8,
9
Passed all tests!
