iterative quicksort using stack - c

Question

Hi can someone help me with my code im not sure where I went wrong
this is for iterative quicksort using stack the arrays are passed by using void ** pointers
int partition(void **A, int n, void *pivot){
void * temp;
int left = 0,j = 0;
int right = n-1;
int i = left;
for (j=left;j<right;j++){
if ((long)A[j] < (long)pivot){
i++;
temp = A[i];
A[i] = A[j];
A[j] = temp;
}
}
temp = A[i+1];
A[right] = A[i+1];
A[i+1] = temp;
return i+1;
}
void myQuicksort(void **A, int n) {
Stack *s = stack_new(); /*making new stack and allocating memory*/
stack_push(s,(int*)0); /*pushing left and then right*/
stack_push(s,(int*)(n-1));
while (!stack_isEmpty(s)){
int right = (int)stack_pop(s); /*poping return right then left*/
int left = (int)stack_pop(s);
if (right-left >=1){
int pivot = (right+left)/2; /* taking middle element as pivot */
int p = partition(A+left , right-left+1 , A[pivot]);/*getting partition index*/
stack_push(s, (int*)left);
stack_push(s, (int*)(p-1));
stack_push(s,(int*)(p+1));
stack_push(s,(int*)right);
}
}
}

Answer 1

Apparently this is the quicksort algorithm you want to implement http://en.wikipedia.org/wiki/Quicksort#Algorithm
First a handy function to swap two pointers to long in A.
void swap(long **A, int i, int j)
{
long *temp = A[i];
A[i] = A[j];
A[j] = temp;
}
The partition function is below.
Note that your code is missing the first swap. You don't need it if you choose hi as pivotIndex. But that is not what you do.
Note also that you do a preincrement of i (storeIndex) which is an error. You should first do the swap and then increment i. I combine the swap and increment in one instruction by using postincrement. Swapping i+1 and returning i+1 at the end is thus wrong.
int partition(long **A, int lo, int hi)
{
int pivotIndex = (hi+lo)/2, storeIndex = lo, i;
long pivotValue = *A[pivotIndex];
swap(A, pivotIndex, hi);
for (i = lo; i < hi; ++i)
if (*A[i] < pivotValue)
swap(A, i, storeIndex++); /* Note: post increment of storeIndex */
swap(A, storeIndex, hi);
return storeIndex;
}
Your function
Je ne serai donc pas disponible mercredi prochain à 11h comme nous avions convenu. myQuickSort then becomes as follow.
Note that your stack must now store int (indexes) and not int*.
void myQuicksort(void **A, int n)
{
int lo, hi, p;
Stack *s = stack_new(); /* making new stack and allocating memory */
stack_push(s, 0); /* pushes initial lo and hi values */
stack_push(s, n-1);
while (!stack_isEmpty(s))
{
hi = stack_pop(s);
lo = stack_pop(s);
if (lo < hi)
{
p = partition(A, lo, hi);
stack_push(s, lo);
stack_push(s, p-1);
stack_push(s, p+1);
stack_push(s, hi);
}
}
}
This code has not been tested because I don't have the stack and the array at hand.
In order to use this code you have to fix your stack so that it stores integers.
I changed your variable name and use hi and lo instead of your method because in this way you only stored integer values on the stack. It's simpler and more clear.
Update:
Since the signature of partition() is imposed here is a new code proposal.
The problem with this signature is that you don't know where the pivot was stored in A. When partition() ends, the pivot value must be stored in A[i]. So we have to find it and store it in A[right] before we start the partitioning.
int partition(void **A, int n, void *pivot){
void * temp;
int left = 0, j = 0;
int right = n-1;
int i = left;
// locate the pivot
for (j = 0; j < n; ++j)
if (*(long*)A[j] == *(long*)pivot)
break;
// swap it with the right most value in A
temp = A[j];
A[j] = A[right];
A[right] = temp;
// do the partition
for (j = 0; j < right; j++){
if (*(long*)A[j] < *(long*)pivot){
temp = A[i];
A[i] = A[j];
A[j] = temp;
i++; // post increment i
}
}
// store the pivot in place
temp = A[i];
A[right] = A[i];
A[i] = temp;
// return the index of the pivot
return i;
}
Here is another possible implementation
int partition(void **A, int n, void *pivot){
void * temp;
int left = 0, j = 0;
int right = n-1;
int i = left;
// do the partition
for (j = 0; j < n; j++){
if (*(long*)A[j] < *(long*)pivot){
temp = A[i];
A[i] = A[j];
A[j] = temp;
i++; // post increment i
}
}
// At this stage the pivot is somewhere in the range A[i] to A[right]
// Lets find it and put it in A[i] if it's not already there
if (*(long*)A[i] != *(long*)pivot){
for (j = i+1; j < n; ++j){
if (*(long*)A[j] == *(long*)pivot){
temp = A[i];
A[i] = A[j];
A[j] = temp;
break;
}
}
}
// return the index of the pivot
return i;
}

Answer 2

There is an obvious bug in your code. Your myQuickSort function pushes and pops integers that are indexes into the array A. But "partition" doesn't know about the whole array; the value that it returns is relative to the start of the array that it was given.
Say you sort an array of 200 items, and eventually you pass the range from 100 to 200 to partition. If it partitions right in the middle, it won't return 150 as you expect, but 50.
I wonder if you actually tried debugging your code.