Part 3(Do this part only with the 4 functions) :Redo Part 1 on the linkedListType.h. You cannot use any predefined member function. All your modifications should be performed inside the header file linkedListType.h that is attached with this assignment. After performing the modifications, you should run the file memberLinkedList.cpp (attached with this assignment) without modifying it without any problems and you should get the following output:

Part 1 : 1. Modify the arrayListType by adding a member function that increase each element in the list by a constant number that it takes as a parameter. This member function does not return any value.

2. Modify the arrayListType by adding a member function that checks every 2 consecutive elements and make them in ascending or descending order depending on a parameter value (letter a means ascending and letter d means descending). 3. Modify the arrayListType by adding a member function that duplicate each item that is greater than a value that is sent to the function as a parameter and remove the items that are smaller than the parameter. 4. Modify the arrayListType by adding a member function that creates 2 new lists from the elements in the list. The fist list should store the elements that are less than a parameter value and the rest of the elements should go to the second list. The original list should not be modified. The 2 new lists can be returned from the function through reference parameters.

#include #include "unorderedLinkedList.h" using namespace std; int main() { unorderedLinkedList L,L1,L2; L.insertlast(2); L.insertlast(1); L.insertlast(3); L.insertlast(4); L.insertlast(5); L.insertlast(3); L.insertlast(0); cout  
#ifndef H_LinkedList #define H_LinkedList #include using namespace std; //*********************************************************** // Author: D.S. Malik // // This class specifies the members to implement the basic // properties of a linked list. This is an abstract class. // We cannot instantiate an object of this class. //*********************************************************** template  struct nodeType { Type info; nodeType * link; }; template  class linkedListType { public: const linkedListType & operator = (const linkedListType &); //Overload the assignment operator. void initializeList(); bool isEmptyList() const; void print() const; int length() const; void destroyList(); Type front() const; Type back() const; virtual bool search(const Type& searchItem) const = 0; virtual void insertfirst(const Type& newItem) = 0; virtual void insertlast(const Type& newItem) = 0; virtual void deleteNode(const Type& deleteItem) = 0; linkedListType(); linkedListType(const linkedListType & otherList); ~linkedListType(); protected: int count; //variable to store the number of list elements nodeType * first; //pointer to the this->first node of the list nodeType * last; //pointer to the this->last node of the list private: void copyList(const linkedListType & otherList); }; template  bool linkedListType  ::isEmptyList() const { return (this->first == NULL); } template  linkedListType  ::linkedListType() //default constructor { this->first = NULL; this->last = NULL; this->count = 0; } template  void linkedListType  ::destroyList() { nodeType * temp; while (this->first != NULL) //while there are nodes in the list { temp = this->first; //set temp to the current node this->first = this->first->link; //advance this->first to the next node delete temp; //deallocate the memory occupied by temp } this->last = NULL; //initialize this->last to NULL; this->first has already //been set to NULL by the while loop this->count = 0; } template  void linkedListType  ::initializeList() { destroyList(); //if the list has any nodes, delete them } template  void linkedListType  ::print() const { nodeType * current; //pointer to traverse the list current = this->first; //set current point to the this->first node while (current != NULL) //while more data to print { cout info link; } cout ::length() const { return this->count; } template  Type linkedListType  ::front() const { assert(this->first != NULL); return this->first->info; //return the info of the this->first node } //end front template  Type linkedListType  ::back() const { assert(this->last != NULL); return this->last->info; //return the info of the this->last node } //end back template  void linkedListType  ::copyList(const linkedListType & otherList) { nodeType * newNode; //pointer to create a node nodeType * current; //pointer to traverse the list if (this->first != NULL) //if the list is nonempty, make it empty destroyList(); if (otherList.first == NULL) //otherList is empty { this->first = NULL; this->last = NULL; this->count = 0; } else { current = otherList.first; //current points to the //list to be copied this->count = otherList.count; //copy the this->first node this->first = new nodeType ; //create the node this->first->info = current->info; //copy the info this->first->link = NULL; //set the link field of the node to NULL this->last = this->first; //make this->last point to the this->first node current = current->link; //make current point to the next // node //copy the remaining list while (current != NULL) { newNode = new nodeType ; //create a node newNode->info = current->info; //copy the info newNode->link = NULL; //set the link of newNode to NULL this->last->link = newNode; //attach newNode after this->last this->last = newNode; //make this->last point to the actual this->last /ode current = current->link; //make current point to the /ext node } //end while } //end else } //end copyList template  linkedListType  ::~linkedListType() //destructor { destroyList(); } template  linkedListType  ::linkedListType(const linkedListType & otherList) { this->first = NULL; copyList(otherList); } //end copy constructor //overload the assignment operator template  const linkedListType & linkedListType  ::operator = (const linkedListType & otherList) { if (this != &otherList) //avoid self-copy { copyList(otherList); } //end else return *this; } #endif
 
#ifndef H_UnorderedLinkedList #define H_UnorderedLinkedList #include"linkedListType.h" //*********************************************************** // Author: D.S. Malik // // This class specifies the members to implement the basic // properties of an unordered linked list. This class is // derived from the class linkedListType. //*********************************************************** template  class unorderedLinkedList : public linkedListType  { public: bool search(const Type& searchItem) const; //Function to determine whether searchItem is in the list. //Postcondition: Returns true if searchItem is in the list, // otherwise the value false is returned. void insertfirst(const Type& newItem); //Function to insert newItem at the beginning of the list. //Postcondition: this->first points to the new list, newItem is // inserted at the beginning of the list, this->last points to // the this->last node, and this->count is incremented by 1. // void insertlast(const Type& newItem); //Function to insert newItem at the end of the list. //Postcondition: this->first points to the new list, newItem is // inserted at the end of the list, this->last points to the // this->last node, and this->count is incremented by 1. void deleteNode(const Type& deleteItem); //Function to delete deleteItem from the list. //Postcondition: If found, the node containing deleteItem // is deleted from the list. this->first points to the this->first // node, this->last points to the this->last node of the updated // list, and this->count is decremented by 1. }; template  bool unorderedLinkedList  :: search(const Type& searchItem) const { nodeType * current; //pointer to traverse the list bool found = false; current = this->first; //set current to point to the this->first /ode in the list while (current != NULL && !found) //search the list if (current->info == searchItem) //searchItem is found found = true; else current = current->link; //make current point to //the next node return found; } //end search template  void unorderedLinkedList  ::insertfirst(const Type& newItem) { nodeType * newNode; //pointer to create the new node newNode = new nodeType ; //create the new node newNode->info = newItem; //store the new item in the node newNode->link = this->first; //insert newNode before this->first this->first = newNode; //make this->first point to the actual this->first node this->count++; //increment this->count if (this->last == NULL) //if the list was empty, newNode is also //the this->last node in the list this->last = newNode; } //end insertthis->first template  void unorderedLinkedList  ::insertlast(const Type& newItem) { nodeType * newNode; //pointer to create the new node newNode = new nodeType ; //create the new node newNode->info = newItem; //store the new item in the node newNode->link = NULL; //set the link field of newNode to NULL if (this->first == NULL) //if the list is empty, newNode is //both the this->first and this->last node { this->first = newNode; this->last = newNode; this->count++; //increment this->count } else //the list is not empty, insert newNode after this->last { this->last->link = newNode; //insert newNode after this->last this->last = newNode; //make this->last point to the actual //this->last node in the list this->count++; //increment this->count } } //end insertthis->last template  void unorderedLinkedList  ::deleteNode(const Type& deleteItem) { nodeType * current; //pointer to traverse the list nodeType * trailCurrent; //pointer just before current bool found; if (this->first == NULL) //Case 1; the list is empty. cout first->info == deleteItem) //Case 2 { current = this->first; this->first = this->first->link; this->count--; if (this->first == NULL) //the list has only one node this->last = NULL; delete current; } else //search the list for the node with the given info { found = false; trailCurrent = this->first; //set trailCurrent to point //to the this->first node current = this->first->link; //set current to point to //the second node while (current != NULL && !found) { if (current->info != deleteItem) { trailCurrent = current; current = current->link; } else found = true; } //end while if (found) //Case 3; if found, delete the node { trailCurrent->link = current->link; this->count--; if (this->last == current) /ode to be deleted was the //this->last node this->last = trailCurrent; //update the value of this->last delete current; //delete the node from the list } else cout   List I before LincrementByConstant(3) contains: 2134530 List L after L.incrementByConstant(3) contains: 5467863 List I before L.sortEach2('a') contains: 2134530 List L after L.sortEach2('a') contains: 1234350 List L before L.sortEach2('d') contains: 2134530 List L after L.sortEach2('d') contains: 2143530 List I before L.duplicate Orremove(3) contains: 2134530 List L after L.duplicate Orremove(3) contains: 344553 List L before L.split(3,L1,L2) contains: 2134530 List L after L.split(3,L1,L2) contains: 2134530 List L1 after L.split(3,L1,L2) contains: 210 List L2 after L.split(3,L1,L2) contains: 3453  List I before LincrementByConstant(3) contains: 2134530 List L after L.incrementByConstant(3) contains: 5467863 List I before L.sortEach2('a') contains: 2134530 List L after L.sortEach2('a') contains: 1234350 List L before L.sortEach2('d') contains: 2134530 List L after L.sortEach2('d') contains: 2143530 List I before L.duplicate Orremove(3) contains: 2134530 List L after L.duplicate Orremove(3) contains: 344553 List L before L.split(3,L1,L2) contains: 2134530 List L after L.split(3,L1,L2) contains: 2134530 List L1 after L.split(3,L1,L2) contains: 210 List L2 after L.split(3,L1,L2) contains: 3453