Answer Happy

Instructions (Ordered Sets) Redo Programming Exercise 13 of
Chapter 12 using templates.
arrayListType.h
#ifndef H_arrayListType
#define H_arrayListType
#include <iostream>
using namespace std;
class arrayListType
{
public:
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 maximum 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, int item) const;
//Function to determine whether item is the same as
//the item in the list at the position specified
//by location.
//Postcondition: Returns true if list[location]
// is the same as item; otherwise,
// returns false.
// If location is out of range, an
// appropriate message is displayed.
virtual void insertAt(int location, int insertItem) = 0;
//Function to insert insertItem in the list at the
//position specified by location.
//Note that this is an abstract function.
//Postcondition: Starting at location, the elements of
// the list are shifted down,
// list[location] = insertItem; length++;
// If the list is full or location is out of
// range, an appropriate message is displayed.
virtual void insertEnd(int insertItem) = 0;
//Function to insert insertItem at the end of
//the list. Note that this is an abstract function.
//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, int& 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.
virtual void replaceAt(int location, int repItem) = 0;
//Function to replace the elements in the list
//at the position specified by location.
//Note that this is an abstract function.
//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;
virtual int seqSearch(int searchItem) const = 0;
//Function to search the list for searchItem.
//Note that this is an abstract function.
//Postcondition: If the item is found, returns the
// location in the array where the item is
// found; otherwise, returns -1.
virtual void remove(int removeItem) = 0;
//Function to remove removeItem from the list.
//Note that this is an abstract function.
//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
virtual ~arrayListType();
//Destructor
//Deallocate the memory occupied by the array.
protected:
int *list; //array to hold the list elements
int length; //variable to store the length of the list
int maxSize; //variable to store the maximum
//size of the list
};
bool arrayListType::isEmpty() const
{
return (length == 0);
} //end isEmpty
bool arrayListType::isFull() const
{
return (length == maxSize);
} //end isFull
int arrayListType::listSize() const
{
return length;
} //end listSize
int arrayListType::maxListSize() const
{
return maxSize;
} //end maxListSize
void arrayListType::print() const
{
for (int i = 0; i < length; i++)
cout << list << " ";
cout << endl;
} //end print
bool arrayListType::isItemAtEqual(int location, int item)
const
{
if (location < 0 || location >= length)
{
cout << "The location of the item to be removed "
<< "is out of range." << endl;
return false;
}
else
return (list[location] == item);
} //end isItemAtEqual
void arrayListType::removeAt(int location)
{
if (location < 0 || location >= length)
cout << "The location of the item to be removed "
<< "is out of range." << endl;
else
{
for (int i = location; i < length - 1; i++)
list = list[i+1];
length--;
}
} //end removeAt
void arrayListType::retrieveAt(int location, int& retItem)
const
{
if (location < 0 || location >= length)
cout << "The location of the item to be retrieved is "
<< "out of range" << endl;
else
retItem = list[location];
} //end retrieveAt
void arrayListType::clearList()
{
length = 0;
} //end clearList
arrayListType::arrayListType(int size)
{
if (size <= 0)
{
cout << "The array size must be positive. Creating "
<< "an array of the size 100." << endl;
maxSize = 100;
}
else
maxSize = size;
length = 0;
list = new int[maxSize];
} //end constructor
arrayListType::~arrayListType()
{
delete [] list;
} //end destructor
arrayListType::arrayListType(const arrayListType&
otherList)
{
maxSize = otherList.maxSize;
length = otherList.length;
list = new int[maxSize]; //create the array
for (int j = 0; j < length; j++) //copy otherList
list [j] = otherList.list[j];
}//end copy constructor
#endif
main.cpp
#include <iostream>
using namespace std;
int main() {
// Write your main here
return 0;
}
orderedArrayListType.h
#ifndef H_orderedArrayListType
#define H_orderedArrayListType
#include <iostream>
#include "arrayListType.h"
using namespace std;
class orderedArrayListType: public arrayListType
{
public:
virtual void insertAt(int location, int insertItem);
virtual void insertEnd(int insertItem);
virtual void replaceAt(int location, int repItem);
virtual int seqSearch(int searchItem) const;
virtual void insert(int insertItem);
virtual void remove(int removeItem);
orderedArrayListType(int size = 100);
//Constructor
};
void orderedArrayListType::insert(int insertItem)
{
if (length == 0) //list is empty
list[length++] = insertItem; //insert insertItem
//and increment length
else if (length == maxSize)
cout << "Cannot insert in a full list." << endl;
else
{
//Find the location in the list where to insert
//insertItem.
int loc;
for (loc = 0; loc < length; loc++)
{
if (list[loc] >= insertItem)
{
break;
}
}
for (int i = length; i > loc; i--)
list = list; //move the elements down
list[loc] = insertItem; //insert insertItem
length++; //increment the length
}
} //end insert
int orderedArrayListType::seqSearch(int searchItem) const
{
int loc;
bool found = false;
for (loc = 0; loc < length; loc++)
{
if (list[loc] >= searchItem)
{
found = true;
break;
}
}
if (found)
{
if (list[loc] == searchItem)
return loc;
else
return -1;
}
else
return -1;
} //end seqSearch
void orderedArrayListType::insertAt(int location, int
insertItem)
{
if (location < 0 || location >= maxSize)
cout << "The position of the item to be "
<< "inserted is out of range." << endl ;
else if (length == maxSize) //list is full
cout << "Cannot insert in a full list." << endl;
else
{
cout << "This is a sorted list. Inserting at the proper
place."
<< endl;
insert(insertItem);
}
} //end insertAt
void orderedArrayListType::insertEnd(int insertItem)
{
if (length == maxSize) //the list is full
cout << "Cannot insert in a full list." << endl;
else
{
cout << "This is a sorted list. Inserting at the proper
"
<< "place." << endl;
insert(insertItem);
}
} //end insertEnd
void orderedArrayListType::replaceAt(int location, int
repItem)
{
if (location < 0 || location >= length)
cout << "The location of the item to be replaced is out
"
<< "of range." << endl;
else
{
removeAt(location);
insert(repItem);
}
} //end replaceAt
void orderedArrayListType::remove(int removeItem)
{
int loc;
if (length == 0)
cout << "Cannot delete from an empty list." <<
endl;
else
{
loc = seqSearch(removeItem);
if (loc != -1)
removeAt(loc);
else
cout << "The item to be deleted is not in the list."
<< endl;
}
} //end remove
orderedArrayListType::orderedArrayListType(int size)
: arrayListType(size)
{
}
#endif
orderedSetType.h
#ifndef H_orderedSetType
#define H_orderedSetType
#include <iostream>
#include "orderedArrayListType.h"
using namespace std;
class orderedSetType: public orderedArrayListType
{
public:
void insert(int insertItem);
void replaceAt(int location, int repItem);
orderedSetType(int size = 100);
//Constructor
};
void orderedSetType::insert(int insertItem)
{
int loc;
bool found = false;
if (length == 0) //list is empty
list[length++] = insertItem; //insert insertItem
//and increment length
else if (length == maxSize)
cout << "Cannot insert in a full list." << endl;
else
{
for (loc = 0; loc < length; loc++)
{
if (list[loc] >= insertItem)
{
found = true;
break;
}
}
if (found)
found = (list[loc] == insertItem);
if (!found) //insertItem is not in list
{
for (int i = length; i > loc; i--)
list = list; //move the
//elements down
list[loc] = insertItem; //insert insertItem
length++; //increment the length
}
else
cout << "The item to be inserted is already in the list.
"
<< "No duplicates are allowed." << endl;
}
} //end insert
void orderedSetType::replaceAt(int location, int repItem)
{
if (location < 0 || location >= length)
cout << "The location of the item to be "
<< "replaced is out of range." << endl;
else
{
int loc = seqSearch(repItem);
if (loc == -1)
{
removeAt(location);
insert(repItem);
}
else
cout << "The item to be inserted is already in the list."
<< endl;
}
} //end replaceAt
orderedSetType::orderedSetType(int size)
: orderedArrayListType(size)
{
} //end constructor
#endif