Question

Create an h file called list. It should have the following features:

lisi's funnc In no particular order: List(): Default constructor. This should construct an empty List, the member variables should be initialized to reflect this state. This function is already fully implemented. 1. List(const List<Type>& other): Copy constructor for the linked list. This should create an entirely new linked list with the same number of Nodes and the Values stored these Nodes in the same order as seen the other list's Nodes. This should not result in any memory leaks or aliasing. 2. 3. List<Type>& operator-(const List<Type>& other): Overloaded assignment operator for the linked list. Causes the already existing linked list to be identical to the other linked list without causing any memory leaks or aliasing. 4 "List(): Destructor. The list dynamically allocates nodes, that means when we destruct your list we need to ensure we deallocated the nodes appropriately to avoid memory leaks void printltems() const: Traverses the list and prints the items in the list in a single line, followed by a newline. For example suppose our list contains the strings "Cash", "Shell", and "Ruby", printltems will display in the console: 5. Cash Shell Ruby 6. bool isEmpty) const: returns boolean value indicating if the list is empty or not 7. void addToFront(const Type &item): Adds item to a new Node at the Front of the list. Updates head, tail, and size accordingly. Must appropriately handle cases in which the list is empty and if there are nodes already in the list void addToRear(const Type &item): Adds item to a new Node at the Rear of the list. Updates head, tail, and size accordingly. Must appropriately handle cases in which the list is empty and if there are nodes already in the list 8. 9. void addtem(int index, const Type &item): Given an index, this function adds the item to a new Node at the index. Updates head, tail, and size accordingly. If the index is less than or equal to zero add the item to the front. If the index is greater than or equal to the size of the list then add it to the rear. Otherwise add the item at the index indicated

Answer 1

// list.h

#ifndef LIST_H_

#define LIST_H_

#include <iostream>

using namespace std;

template <class Type>

struct Node

{

               Type data;

               Node<Type> *next;

};

template <class Type>

class List

{

private:

               Node<Type> *head;

               Node<Type> *tail;

               int size;

public:

               List();

               List(const List<Type> &other);

               List<Type>& operator=(const List<Type> &other);

               ~List();

               void printItems() const;

               bool isEmpty() const;

               void addToFront(const Type &item);

               void addToRear(const Type &item);

               void addItem(int index, const Type&item);

};

template <class Type>

List<Type>::List()

{

               head = NULL;

               tail = NULL;

               size = 0;

}

template <class Type>

List<Type>::List(const List<Type> &other)

{

               head = NULL;

               tail = NULL;

               size = 0;

               Node<Type> *curr = other.head;

               while(curr != NULL)

               {

                              addToRear(curr);

                              curr = curr->next;

               }

}

template <class Type>

List<Type>& List<Type>::operator=(const List<Type> &other)

{

               if(this != &other)

               {

                              while(head != NULL)

                              {

                                             Node<Type> *temp = head;

                                             head = head->next;

                                             delete(temp);

                              }

                              tail = NULL;

                              size =0;

                              Node<Type> *curr = other.head;

                              while(curr != NULL)

                              {

                                             addToRear(curr);

                                             curr = curr->next;

                              }

               }

               return *this;

}

template <class Type>

List<Type>::~List()

{

               while(head != NULL)

               {

                              Node<Type> *temp = head;

                              head = head->next;

                              delete(temp);

               }

               tail = NULL;

               size =0;

}

template <class Type>

void List<Type>::printItems() const

{

               if(head != NULL)

               {

                              Node<Type> *node = head;

                              while(node != NULL)

                              {

                                             cout<<node->data<<" ";

                                             node = node->next;

                              }

                              cout<<endl;

               }else

                              cout<<"Empty List"<<endl;

}

template <class Type>

bool List<Type>::isEmpty() const

{

               return(head == NULL);

}

template <class Type>

void List<Type>::addToFront(const Type &item)

{

               Node<Type> *node = new Node<Type>();

               node->data = item;

               node->next = NULL;

               node->next = head;

               head = node;

               if(head->next == NULL)

                              tail = head;

               size++;

}

template <class Type>

void List<Type>::addToRear(const Type &item)

{

               if(isEmpty())

                              addToFront(item);

               else

               {

                              Node<Type> *node = new Node<Type>();

                              node->data = item;

                              node->next = NULL;

                              tail->next = node;

                              tail = node;

                              size++;

               }

}

template <class Type>

void List<Type>::addItem(int index, const Type &item)

{

               if(index <= 0)

                              addToFront(item);

               else if(index >= size)

                              addToRear(item);

               else

               {

                              Node<Type> *node = new Node<Type>();

                              node->data = item;

                              node->next = NULL;

                              Node<Type> *curr = head;

                              Node<Type> *prev = NULL;

                              int i=0;

                              while(i < index)

                              {

                                             prev = curr;

                                             curr = curr->next;

                                             i++;

                              }

                              prev->next = node;

                              node->next = curr;

                              size++;

               }

}

#endif /* LIST_H_ */

//end of list.h

// main.cpp

#include <iostream>

#include "list.h"

using namespace std;

int main()

{

               List<int> list;

               for(int i=0;i<5;i++)

                              list.addToRear(i);

               cout<<"List : "<<endl;

               list.printItems();

               list.addToFront(10);

               list.addItem(0,11);

               list.addItem(8,12);

               list.addItem(5,13);

               cout<<"List : "<<endl;

               list.printItems();

               return 0;

}

//end of main.cpp

Output:

List 0 1 2 34 List 11 10 0 1 2 13 3 4 12