Counting basic operations in Quicksort algorithm - c++

Question

I am trying to count the amount of basic operations done by Hoare's quicksort algorithm. I am wondering if I placed the counter in the correct position. My assignment is to count the number of basic operations on 100 randomly generated arrays of sizes 10,100,1k, and 10k.
Here is the algorithm with the counter placed (line 6):
void QuickSort(int* array, int startIndex, int endIndex, int &counter) {
int pivot = array[startIndex]; //pivot element is the leftmost element
int splitPoint;
if (endIndex > startIndex)
{
counter++; //counting
splitPoint = SplitArray(array, pivot, startIndex, endIndex);
array[splitPoint] = pivot;
QuickSort(array, startIndex, splitPoint - 1, counter); //Quick sort first half
QuickSort(array, splitPoint + 1, endIndex, counter); //Quick sort second half
}
}
void swap(int &a, int &b) {
int temp;
temp = a;
a = b;
b = temp;
}
int SplitArray(int* array, int pivot, int startIndex, int endIndex) {
int leftBoundary = startIndex;
int rightBoundary = endIndex;
while (leftBoundary < rightBoundary)
{
while (pivot < array[rightBoundary]
&& rightBoundary > leftBoundary)
{
rightBoundary--;
}
swap(array[leftBoundary], array[rightBoundary]);
while (pivot >= array[leftBoundary]
&& leftBoundary < rightBoundary)
{
leftBoundary++;
}
swap(array[rightBoundary], array[leftBoundary]);
}
return leftBoundary;
}
Do these results make sense?
Array[Amount] Array[10] Array[100] Array[1k] Array[10k]
MAX: 8 72 682 7122
MIN: 5 63 653 7015
AVERAGE: 6.36 66.54 667.87 7059.41
Or did I put the counter in the wrong place.

Answer 1

The counter is in the wrong place. Your assignment is to count basic operations. What is a basic operation in sorting? Typically we count the number of compare operations to measure complexity of sort.
We know that QuickSort is O(N Log N) on average where N is the number of items being sorted, while worst case it is O(N^2).
Your numbers are smaller than N, which is not possible since each of the N items must be compared to some other elemnt at least once, the cost of sorting cannot be less than N (otherwise at least one element was not compared to anything, so you could not guaranteed that it is sorted).
In your algorithm, the compare operation occurs when you compare the elements of the array to the pivot value. So increment your counter every time you compare an array element to Pivot. Your measured numbers should be at least N, and will typically be about N*log N, and rarely be be close to N^2.
See the suggested points below in SplitArray where to increment counter:
void QuickSort(int* array, int startIndex, int endIndex, int &counter) {
int pivot = array[startIndex]; //pivot element is the leftmost element
int splitPoint;
if (endIndex > startIndex)
{
// counter++; // Don't count here
splitPoint=SplitArray(array, pivot, startIndex, endIndex, counter);
array[splitPoint] = pivot;
QuickSort(array, startIndex, splitPoint - 1, counter); //Quick sort first half
QuickSort(array, splitPoint + 1, endIndex, counter); //Quick sort second half
}
}
No change to swap:
void swap(int &a, int &b) {
int temp;
temp = a;
a = b;
b = temp;
}
SplitArray does the comparisons, so the counter should be incremented here:
int SplitArray(int* array,int pivot,int startIndex,int endIndex,int &counter) {
int leftBoundary = startIndex;
int rightBoundary = endIndex;
while ((++counter) && (leftBoundary < rightBoundary))
{
while (pivot < array[rightBoundary]
&& rightBoundary > leftBoundary)
{
rightBoundary--;
}
swap(array[leftBoundary], array[rightBoundary]);
while ((++counter) && (pivot >= array[leftBoundary])
&& leftBoundary < rightBoundary)
{
leftBoundary++;
}
swap(array[rightBoundary], array[leftBoundary]);
}
return leftBoundary;
}