C quick sort function keeps crashing - c

Question

Part of an assignment I'm doing for school involved building a quick sort to sort an array. I'm pretty sure I have it close, however whenever I call it, it crashes on me
void quickSort(double * array, unsigned int size, int start, int stop)
{
int swapIndex = start;
int pivot = start;
double temp;
if (size > 1)
{
for (int i = pivot + 1; i < stop; ++i)
{
if (array[pivot] > array[i])
{
++swapIndex;
temp = array[i];
array[i] = array[swapIndex];
array[swapIndex] = temp;
}
}
temp = array[swapIndex];
array[swapIndex] = array[pivot];
array[pivot] = temp;
quickSort(array, size, start, swapIndex);
quickSort(array, size, swapIndex, size);
}
}
http://pastebin.com/Ccv4KP3j

Answer 1

N.B. This answer's based off the pastebin link as of 27/2/2016
First of all your function has the wrong return type - quicksort works in-place, meaning that it doesn't create any new arrays; it sorts the array you passed to it. It will work perfectly as a void function.
Remember that in C, arrays can only be passed by reference, i.e. every recursive call to quicksort deals with exactly the same array.
Your quicksort should work like so:
double arr[] = {12, -2, 4, 5, 2, 1};
quicksort(arr, 0, 5);
// arr is now sorted
int i;
for (i=0; i<6; i++){
printf("%f, ", arr[i]);
}
printf("\n");
// prints "-2, 1, 2, 4, 5, 12"
For the sake of clarity, I'd recommend writing a function void doubleSwap(double *a, double* b) to take care of all the element swapping without muddying your code.
The reason your code results in stack overflows is twofold:
The initial if guard needs to check if start and stop differ by
more than one, not just if they're different.
The 'swapIndex' variable always overlaps the pivot cell, resulting in
confusion as the pivot value gets mutated before the
whole array is processed. It can be fixed by setting pivot to
stop - 1.
Here is a pastebin of my version of your code, but before looking at it, try to debug it yourself using a bunch of printfs.
Also note that you don't have to pass the whole array to qsort - you can replace quickSort(array, swapIndex, stop) with quickSort(array + swapIndex, 0, stop - swapIndex), allowing you to get rid of start altogether because it's always zero.
void doubleSwap(double *a, double*b){
double temp = *a;
*a = *b;
*b = temp;
}
void quickSort(double * array, int start, int stop)
{
int pivot = stop - 1;
int swapIndex = start;
int i;
if (start < stop - 1) {
for (i = start; i < stop; i++) {
if (array[i] < array[pivot]){
doubleSwap(array + swapIndex, array + i);
swapIndex++;
}
}
// Note that `array + swapIndex` is equivalent to `&(array[swapIndex])`
doubleSwap(array + swapIndex, array + pivot);
fprintf(stderr, "swapIndex = %d start = %d stop = %d\n", swapIndex, start, stop);
for (i = 0; i< NELEMS; i++){
fprintf(stderr, "%3f, ", array[i]);
}
fprintf(stderr, "\n");
quickSort(array, start, swapIndex);
quickSort(array, swapIndex, stop);
}
}