#ifndef ARRAY_LIST_TYPE

#define ARRAY_LIST_TYPE

#include

#include

using namespace std;

//***********************************************************

// Author: D.S. Malik

//

// This class specifies the members to implement the basic

// properties of array-based lists.

//***********************************************************

template

class arrayListType {

public:

const arrayListType & operator =

(const arrayListType & );

//Overloads the assignment operator

bool isEmpty() const;

//Function to determine whether the list is empty

//Postcondition: Returns true if the list is empty;

// otherwise, returns false.

bool isFull() const;

//Function to determine whether the list is full.

//Postcondition: Returns true if the list is full;

// otherwise, returns false.

int listSize() const;

//Function to determine the number of elements in the list

//Postcondition: Returns the value of length.

int maxListSize() const;

//Function to determine the size of the list.

//Postcondition: Returns the value of maxSize.

void print() const;

//Function to output the elements of the list

//Postcondition: Elements of the list are output on the

// standard output device.

bool isItemAtEqual(int location,const elemType & item) const;

//Function to determine whether the item is the same

//as the item in the list at the position specified by

//Postcondition: Returns true if list[location]

// is the same as the item; otherwise,

// returns false.

void insertAt(int location,const elemType & insertItem);

//Function to insert an item in the list at the

//position specified by location. The item to be inserted

//is passed as a parameter to the function.

//Postcondition: Starting at location, the elements of the

// list are shifted down, list[location] = insertItem;,

// and length++;. If the list is full or location is

// out of range, an appropriate message is displayed.

void insertEnd(const elemType & insertItem);

//Function to insert an item at the end of the list.

//The parameter insertItem specifies the item to be inserted.

//Postcondition: list[length] = insertItem; and length++;

// If the list is full, an appropriate message is

// displayed.

void removeAt(int location);

//Function to remove the item from the list at the

//position specified by location

//Postcondition: The list element at list[location] is removed

// and length is decremented by 1. If location is out of

// range, an appropriate message is displayed.

void retrieveAt(int location, elemType & retItem) const;

//Function to retrieve the element from the list at the

//position specified by location.

//Postcondition: retItem = list[location]

// If location is out of range, an appropriate message is

// displayed.

void replaceAt(int location,const elemType & repItem);

//Function to replace the elements in the list at the

//position specified by location. The item to be replaced

//is specified by the parameter repItem.

//Postcondition: list[location] = repItem

// If location is out of range, an appropriate message is

// displayed.

void clearList();

//Function to remove all the elements from the list.

//After this operation, the size of the list is zero.

//Postcondition: length = 0;

int seqSearch(const elemType & item) const;

//Function to search the list for a given item.

//Postcondition: If the item is found, returns the location

// in the array where the item is found; otherwise,

// returns -1.

void insert(const elemType & insertItem);

//Function to insert the item specified by the parameter

//insertItem at the end of the list. However, first the

//list is searched to see whether the item to be inserted

//is already in the list.

//Postcondition: list[length] = insertItem and length++

// If the item is already in the list or the list

// is full, an appropriate message is displayed.

void remove(const elemType & removeItem);

//Function to remove an item from the list. The parameter

//removeItem specifies the item to be removed.

//Postcondition: If removeItem is found in the list,

// it is removed from the list and length is

// decremented by one.

arrayListType(int size = 100);

//constructor

//Creates an array of the size specified by the

//parameter size. The default array size is 100.

//Postcondition: The list points to the array, length = 0,

// and maxSize = size

arrayListType(const arrayListType & otherList);

//copy constructor

~arrayListType();

//destructor

//Deallocates the memory occupied by the array.

protected:

elemType * list; //array to hold the list elements

int length; //to store the length of the list

int maxSize; //to store the maximum size of the list

};

template

bool arrayListType ::isEmpty() const {

return (length == 0);

}

template

bool arrayListType ::isFull() const {

return (length == maxSize);

}

template

int arrayListType ::listSize() const {

return length;

}

template

int arrayListType ::maxListSize() const {

return maxSize;

}

template

void arrayListType ::print() const {

for (int i = 0; i

cout

cout

}

template

bool arrayListType ::isItemAtEqual(int location, const elemType & item) const {

if (location = length){

cerr

"is out of range"

return false;

}

return (list[location] == item);

}

template

void arrayListType ::insertAt(int location,

const elemType & insertItem) {

if (location length)

cerr

"is out of range"

else if (length >= maxSize) //list is full

cerr

else {

for (int i = length; i > location; i--)

list[i] = list[i - 1]; //move the elements down

list[location] = insertItem; //insert the item at the

//specified position

length++; //increment the length

}

} //end insertAt

template

void arrayListType ::insertEnd(const elemType & insertItem) {

if (length >= maxSize) //the list is full

cerr

else {

list[length] = insertItem; //insert the item at the end

length++; //increment the length

}

} //end insertEnd

template

void arrayListType ::removeAt(int location) {

if (location = length)

cerr

"is out of range"

else {

for (int i = location; i

list[i] = list[i + 1];

length--;

}

} //end removeAt

template

void arrayListType ::retrieveAt(int location, elemType & retItem) const {

if (location = length)

cerr

"out of range."

else

retItem = list[location];

} //end retrieveAt

template

void arrayListType ::replaceAt(int location,

const elemType & repItem)

{

if (location = length)

cerr

"out of range."

else

list[location] = repItem;

} //end replaceAt

template

void arrayListType ::clearList() {

length = 0;

} //end clearList

template

arrayListType ::arrayListType(int size) {

if (size

cerr

"an array of size 100. "

maxSize = 100;

} else

maxSize = size;

length = 0;

list = new elemType[maxSize];

assert(list != NULL);

}

template

arrayListType ::~arrayListType() {

delete[] list;

}

template

arrayListType ::arrayListType(const arrayListType & otherList) {

maxSize = otherList.maxSize;

length = otherList.length;

list = new elemType[maxSize]; //create the array

assert(list != NULL); //terminate if unable to allocate

//memory space

for (int j = 0; j

list[j] = otherList.list[j];

} //end copy constructor

template

const arrayListType & arrayListType ::operator =

(const arrayListType & otherList) {

if (this != & otherList) //avoid self-assignment

{

delete[] list;

maxSize = otherList.maxSize;

length = otherList.length;

list = new elemType[maxSize]; //create the array

assert(list != NULL); //if unable to allocate memory

//space, terminate the program

for (int i = 0; i

list[i] = otherList.list[i];

}

return *this;

}

template

int arrayListType ::seqSearch(const elemType & item) const {

int loc;

bool found = false;

for (loc = 0; loc

if (list[loc] == item) {

found = true;

break;

}

if (found)

return loc;

else

return -1;

} //end seqSearch

template

void arrayListType ::insert(const elemType & insertItem) {

int loc;

if (length == 0) //list is empty

list[length++] = insertItem; //insert the item and

//increment the length

else if (length == maxSize)

cerr

else {

loc = seqSearch(insertItem);

if (loc == -1) //the item to be inserted

//does not exist in the list

list[length++] = insertItem;

else

cerr

"the list. No duplicates are allowed."

}

} //end insert

template

void arrayListType ::remove(const elemType & removeItem) {

int loc;

if (length == 0)

cerr

else {

loc = seqSearch(removeItem);

if (loc != -1)

removeAt(loc);

else

cout

endl;

}

} //end remove

#endif // ARRAY_LIST_TYPE

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. For example, if a list L contains the elements 2,1,3,4,5,3,0 and you call the member function as in L.duplicate Rremove(3); The list content will then be changed to 3,4,4,5,5,3