Question

I would like to add compare++ to this code in order to count how many compares are done by this algorithm. Does the count of compare need to be incremented on each execution of the first while loop in Merge(...) and in the if and else inside the while? Are these the only locations where compare should be incremented? (I added this increment where I thought it belonged and commented out. Please ignore the swap function)

#include "MergeSort.h"

template<class ItemType>
void MergeClass<ItemType>::sort(ItemType values[], int first, int last)
// Post: The elements in values are sorted by key.
{
    if (first < last)
    {
        int middle = (first + last) / 2;
        sort(values, first, middle);
        sort(values, middle + 1, last);
        Merge(values, first, middle, middle + 1, last);
    }
}

template<class ItemType>
void MergeClass<ItemType>::Merge(ItemType values[], int leftFirst, int leftLast,
int rightFirst, int rightLast)
// Post: values[leftFirst]..values[leftLast] and
// values[rightFirst]..values[rightLast] have been merged.
// values[leftFirst]..values[rightLast] are now sorted.
{
    ItemType tempArray[5];
    int index = leftFirst;
    int saveFirst = leftFirst;
    while ((leftFirst <= leftLast) && (rightFirst <= rightLast))
    {
        if (values[leftFirst] < values[rightFirst])
        {
            tempArray[index] = values[leftFirst];
            leftFirst++;
            //compare++;
        }
        else
        {
            tempArray[index] = values[rightFirst];
            rightFirst++;
            //compare++;
        }
        index++;
        //compare++;
    }
    while (leftFirst <= leftLast)
    // Copy remaining items from left half.
    {
        tempArray[index] = values[leftFirst];
        leftFirst++;
        index++;
    }
    while (rightFirst <= rightLast)
    // Copy remaining items from right half.
    {
        tempArray[index] = values[rightFirst];
        rightFirst++;
        index++;
    }
    for (index = saveFirst; index <= rightLast; index++)
        values[index] = tempArray[index];
}


template<class ItemType>
inline void MergeClass<ItemType>::Swap(ItemType& item1, ItemType& item2)
// Post: Contents of item1 and item2 have been swapped.
{
    ItemType tempItem;
    tempItem = item1;
    item1 = item2;
    item2 = tempItem;
}

template<class ItemType>
MergeClass<ItemType>::MergeClass()
{
    compare = 0;
    swap = 0;
}
template<class ItemType>
void MergeClass<ItemType>::sortPreformance()
{
    cout << "Comparisons made: " << compare <<endl;
    cout << "Swaps made: "<< swap <<endl;
}

Answer 1

If it’s meant strictly for profiling, I’d put the counting logic outside of the sorting class. That is something like the following (which just counts the number of comparisons and swaps used by std::sort):

#include <iostream>
#include <algorithm>
#include <cstdlib>
using namespace std;

template<typename T>
struct CountingItem {
    CountingItem(const T& val = T()) : val_(val) {}

    bool operator<(const CountingItem<T>& rhs) const {
        ++compares;
        return val_ < rhs.val_;
    }

    static size_t compares;
    static size_t swaps;
    T val_;
};

template<typename T>
size_t CountingItem<T>::compares = 0;
template<typename T>
size_t CountingItem<T>::swaps = 0;

template<typename T>
void swap(CountingItem<T>& a, CountingItem<T>& b) {
    ++CountingItem<T>::swaps;
    std::swap(a, b);
}

int main()
{
    const size_t num_items = 10000;
    CountingItem<int> items[num_items];
    for(int i = 0; i < num_items; i++) items[i] = rand() % 100;
    sort(items, items+num_items);
    cout << "Compares = " << CountingItem<int>::compares << endl;
    cout << "Swaps    = " << CountingItem<int>::swaps << endl;

    // Reset CountingItem<int>::compares and swaps here if you're running another test
}