C++ Merge Sort Count Comparison - c++

Question

I am working on a project that asks us to implement different sorts and add counter variables to measure the runtime with different array sizes. My problem is that my current output is not matching the expected output for my Merge Sort. Its only off by a bit.
Any suggestions on what is wrong?
Output:
Array Size: 10 100 1000 10000
--------------------------------------------------------------------
Merge sort 19 569 9275 129630
Expected Output:
Array Size: 10 100 1000 10000
--------------------------------------------------------------------
Merge Sort 19 550 8706 120355
Whats inside the contents of the array for array size 10
Merge sort
[ 935, 942, 697, 299, 382, 579, 408, 181, 366, 505 ] //unsorted
[ 181, 299, 366, 382, 408, 505, 579, 697, 935, 942 ] //sorted
Program:
#include <iostream>
#include <stdlib.h>
#include <iomanip>
#include <cmath>
/******************************/
/* Start of Merge Algorithm */
/******************************/
/**
* The maximum size of the temporary array
*/
const int MAX_SIZE = 10000;
int count = 0; //I added this global variable but It seems Incorrect
/**
* Merges two sorted array segments theArray[first..mid] and
* theArray[mid+1..last] into one sorted array.
*/
template<class ItemType>
void merge(ItemType theArray[], int first, int mid, int last) {
ItemType tempArray[MAX_SIZE]; // Temporary array
// Initialize the local indices to indicate the subarrays
int first1 = first; // Beginning of first subarray
int last1 = mid; // End of first subarray
int first2 = mid + 1; // Beginning of second subarray
int last2 = last; // End of second subarray
// While both subarrays are not empty, copy the
// smaller item into the temporary array
int index = first1; // Next available location in tempArray
while ((first1 <= last1) && (first2 <= last2)) {
// At this point, tempArray[first..index-1] is in order
if (theArray[first1] <= theArray[first2]) {
tempArray[index] = theArray[first1];
first1++;
count++; //I incremented count here
}
else {
tempArray[index] = theArray[first2];
first2++;
count++; //I incremented count here
} // end if
index++;
} // end while
// Finish off the first subarray, if necessary
while (first1 <= last1) {
// At this point, tempArray[first..index-1] is in order
tempArray[index] = theArray[first1];
first1++;
index++;
} // end while
// Finish off the second subarray, if necessary
while (first2 <= last2) {
// At this point, tempArray[first..index-1] is in order
tempArray[index] = theArray[first2];
first2++;
index++;
} // end for
// Copy the result back into the original array
for (index = first; index <= last; index++) {
theArray[index] = tempArray[index];
}
}
/**
* Sorts the items in an array into ascending order.
*/
template<class ItemType>
int mergesort(ItemType theArray[], int first, int last) {
if (first < last) {
// Sort each half
int mid = first + (last - first) / 2;
// Sort left half theArray[first..mid]
mergesort(theArray, first, mid);
// Sort right half theArray[mid+1..last]
mergesort(theArray, mid + 1, last);
// Merge the two halves
merge(theArray, first, mid, last);
}
return count; //return count here
}
/******************************/
/* Start of Sorting Benchmark */
/******************************/
/**
* Generate an array of random integers
*/
int* makeRandomArray(int n, int seed) {
srand(seed);
int * a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = rand() % 1000;
}
return a;
}
int main(){
const int seed = 9000;
int *a;
/******************************/
/* Start of Merge Sort */
/******************************/
std::cout << "Merge sort";
int n = 10;
a = makeRandomArray(10, seed);
std::cout <<std::setw(13)<< mergesort(a, 0, n-1);
delete[] a;
n = 100;
a = makeRandomArray(100, seed);
std::cout <<std::setw(13)<< mergesort(a, 0, n-1);
delete[] a;
n = 1000;
a = makeRandomArray(1000, seed);
std::cout <<std::setw(13)<< mergesort(a, 0, n-1);
delete[] a;
n = 10000;
a = makeRandomArray(10000, seed);
std::cout <<std::setw(13)<< mergesort(a, 0, n-1)<<std::endl;
delete[] a;
}