Write a program to find the number of comparisons using the binary se.docx

Write a program to find the number of comparisons using the
binary search and sequential search algorithms as follows:
Suppose list is an array of 1000 elements. Use a random
number generator to fill the list. Use the function inserterd to
initially insert all the elements in the list. You may use the
following function to fill the list: void
fill(orderedArrayListType& list) { int seed = 47; int multiplier
= 2743; int addOn = 5923; while (list.listSize()
Solution
#include <iostream>
#include <cassert>
#include <fstream>
#include "orderedArrayListType.h"
using namespace std;
void part1();
int main() {
part1();
};
void part1()

{
cout << "
============================|Problem
1|======================================= "
<< endl;
orderedArrayListType<int> myList =
orderedArrayListType<int>(1000);
myList.fill();
int searchElem;
cout << "Pick an integer to search." << endl;
cin >> searchElem;
//following should print number of comparisons within each
function
//search user input for three
cout << "Sequential search found " << searchElem << " at
" << myList.seqSearch(searchElem) << endl;
cout << "Binary search found " << searchElem << " at "
<< myList.binarySearch(searchElem) << endl;
cout << "Binary with seq search found " << searchElem <<
" at " << myList.binaryWithSeqSearch(searchElem) << endl;
cout << "********************Searching existing number
early at index 250************************** " << endl;
myList.retrieveAt(250, searchElem);

cout << "********************Searching existing number
late at index 750********************************* " <<
endl;
myList.retrieveAt(750, searchElem);
int indexSearch;
cout << "*********************Pick an index to search
for (0-
999)********************************************" <<
endl;
cin >> indexSearch;
myList.retrieveAt(indexSearch, searchElem);

}
orderedArrayListType.h
#ifndef H_OrderedListType
#define H_OrderedListType
#include <iostream>
#include "arrayListType.h"
template<class elemType>
class orderedArrayListType: public arrayListType<elemType>
{
public:
void insertOrd(const elemType&);
void fill();
int binarySearch(const elemType& item) const;
int binaryWithSeqSearch(const elemType& item)const;
orderedArrayListType(int size = 100);
};
template <class elemType>
void orderedArrayListType<elemType>::insertOrd(const

elemType& item)
{
int first = 0;
int last = length - 1;
int mid;
bool found = false;
if (length == 0) //the list is empty
{
list[0] = item;
length++;
}
else if (length == maxSize)
cerr << "Cannot insert into a full list." << endl;
else
{
while (first <= last && !found)
{
mid = (first + last) / 2;
if (list[mid] == item)
found = true;
else if (list[mid] > item)
last = mid - 1;
else
first = mid + 1;
}//end while

if (found)
cerr << "The insert item is already in the list. "
<< "Duplicates are not allowed." << endl;
else
{
if (list[mid] < item)
mid++;
insertAt(mid, item);
}
}
}//end insertOrd
int orderedArrayListType<elemType>::binaryWithSeqSearch
(const elemType& item) const
{
int first = 0;
int mid;
bool found = false;
int count = 0;
{
count++;

found = true;
last = mid - 1;
else
first = mid + 1;
//once the partition has reached 15 or below
if (last - first <= 15) {
for (int i = first; i <= last; i++) {
count++;
if (list[i] == item) {
found = true;
break;
}
}
break;
}
}
cout << "Binary search with sequential comparisons: " <<
count << endl;
if (found)
return mid;
else
return -1;

}//end binaryWithSeqSearch
int orderedArrayListType<elemType>::binarySearch
(const elemType& item) const
{
int first = 0;
int mid;
bool found = false;
int count = 0;
count = 2;
{
count++;
found = true;
last = mid - 1;
else
first = mid + 1;
}
cout << "Binary search comparisons: " << count << endl;

if (found)
return mid;
else
return -1;
}//end binarySearch
orderedArrayListType<elemType>::orderedArrayListType(int
size)
: arrayListType<elemType>(size)
{
}
void orderedArrayListType<elemType> :: fill()
{
int seed = 47;
int multiplier = 2743;
int addOn = 5923;
while (listSize() < maxListSize())
{
insertOrd(seed);
seed = int((seed * multiplier + addOn) % 100000);
}
}
#endif

arrayListType.h
#ifndef H_arrayListType
#define H_arrayListType
#include <iostream>
#include <cassert>
class arrayListType
{
public:
const arrayListType<elemType>& operator=
(const arrayListType<elemType>&);
//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 the 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<elemType>& 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
};
bool arrayListType<elemType>::isEmpty() const
{
return (length == 0);
}
bool arrayListType<elemType>::isFull() const
{
return (length == maxSize);
}

int arrayListType<elemType>::listSize() const
{
return length;
}
int arrayListType<elemType>::maxListSize() const
{
return maxSize;
}
void arrayListType<elemType>::print() const
{
for (int i = 0; i < length; i++)
cout << list[i] << " ";
cout << endl;
}
bool arrayListType<elemType>::isItemAtEqual
(int location, const elemType& item) const
{
return(list[location] == item);
}
void arrayListType<elemType>::insertAt
(int location, const elemType& insertItem)

{
if (location < 0 || location >= maxSize)
cerr << "The position of the item to be inserted "
<< "is out of range" << endl;
else if (length >= maxSize) //list is full
cerr << "Cannot insert in a full list" << endl;
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
void arrayListType<elemType>::insertEnd(const elemType&
insertItem)
{
if (length >= maxSize) //the list is full
cerr << "Cannot insert in a full list" << endl;
else
{
list[length] = insertItem; //insert the item at the end
length++; //increment the length

}
} //end insertEnd
void arrayListType<elemType>::removeAt(int location)
{
if (location < 0 || location >= length)
cerr << "The location of the item to be removed "
<< "is out of range" << endl;
else
{
for (int i = location; i < length - 1; i++)
list[i] = list[i+1];
length--;
}
} //end removeAt
void arrayListType<elemType>::retrieveAt
(int location, elemType& retItem) const
{
cerr << "The location of the item to be retrieved is "
<< "out of range." << endl;
else
retItem = list[location];
} //end retrieveAt

void arrayListType<elemType>::replaceAt
(int location, const elemType& repItem)
{
cerr << "The location of the item to be replaced is "
<< "out of range." << endl;
else
list[location] = repItem;
} //end replaceAt
void arrayListType<elemType>::clearList()
{
length = 0;
} //end clearList
int arrayListType<elemType>::seqSearch(const elemType&
item) const
{
int loc;
bool found = false;
int count = 0;
for (loc = 0; loc < length; loc++) {
count++;

if (list[loc] == item)
{
found = true;
break;
}
}
cout << "Sequential search comparisons" << count << endl;
if (found)
return loc;
else
return -1;
} //end seqSearch
void arrayListType<elemType>::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 << "Cannot insert in a full list." << endl;
else
{
loc = seqSearch(insertItem);

if (loc == -1) //the item to be inserted
//does not exist in the list
list[length++] = insertItem;
else
cerr << "the item to be inserted is already in "
<< "the list. No duplicates are allowed." << endl;
}
} //end insert
void arrayListType<elemType>::remove(const elemType&
removeItem)
{
int loc;
if (length == 0)
cerr << "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

arrayListType<elemType>::arrayListType(int size)
{
if (size < 0)
{
cerr << "The array size must be positive. Creating "
<< "an array of size 100. " << endl;
maxSize = 100;
}
else
maxSize = size;
length = 0;
list = new elemType[maxSize];
assert(list != NULL);
}
arrayListType<elemType>::~arrayListType()
{
delete [] list;
}
arrayListType<elemType>::arrayListType
(const arrayListType<elemType>& 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 < length; j++) //copy otherList
list [j] = otherList.list[j];
} //end copy constructor
const arrayListType<elemType>&
arrayListType<elemType>::operator=
(const arrayListType<elemType>& 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 < length; i++)
list[i] = otherList.list[i];
}

Write a program to find the number of comparisons using the binary se.docx

More Related Content

Similar to Write a program to find the number of comparisons using the binary se.docx (20)

More from ajoy21 (20)

Recently uploaded (20)

Write a program to find the number of comparisons using the binary se.docx