quicksort program provides partially sorted output - c

Question

Below simple quick sort code with last element as pivot,almost works but except the last element fails to get sorted. Any thoughts where this program went wrong?
Here's the output:
$a.out
4 3 5 2 1 3 2 3 //input
1 2 2 3 3 3 5 4 //output
Simple swap looks fine
void swap ( int* a, int* b )
{
int t = *a;
*a = *b;
*b = t;
}
Hmm..fine too ..may issue with end?
int partition(int a[],int start,int end){
int pivot = a[end];
int pindex=start;int i;
for ( i=start; i <= end-1; i++){
if (a[i] <= pivot){
swap(&a[i],&a[pindex]);pindex++;
}
}
swap(&a[pindex],&a[pivot]);
return (pindex + 1);
}
Surely looks good.
void quicksort(int a[],int start,int end){
int pindex;
if (start < end){
pindex = partition(a,start,end-1);
quicksort(a,start,pindex-1);
quicksort(a,pindex+1,end);
}
}
Simple main call
int main(){
int a[8] = {4, 3, 5, 2, 1, 3, 2, 3};
int i=0;
for(i=0;i<8;i++)
printf(" %d", a[i]);
quicksort(a,0,8);
printf("\n");
for(i=0;i<8;i++)
printf(" %d", a[i]);
}

Answer 1

Okay couple of changes
As doptimusprime pointed return pindex
int partition(int a[],int start,int end){
int pivot = a[end];
int pindex=start;int i;
for ( i=start; i <= end-1; i++){
if (a[i] <= pivot){
swap(&a[i],&a[pindex]);pindex++;
}
}
swap(&a[pindex],&a[end]);
return (pindex);
}
Adjust your quicksort function accordingly
void quicksort(int a[],int start,int end){
int pindex;
if (start < end){
pindex = partition(a,start,end-1);
quicksort(a,start,pindex); // no pindex-1
quicksort(a,pindex+1,end);
}
}

Answer 2

Please review partition function.
It should return
return pindex;
instead of pindex+1.
Because, just take the following case:
1 2 3 4 5
As 5 is chosen as pivot, it should return 4, not 5 as pivot index.
Check for the invariant that pindex must lie between start and end (both inclusive). If pivot is to be lie at end, it must not pass the end.
Generally, partition starts from both end. You are starting it from the one end. Try to do it both the end for efficiency. Otherwise, in the 1 2 3 4 5, you will keep swapping with the same element (1 with 1, 2 with 2 and so on).
And in the partition:
swap(&a[pindex],&a[pivot]);
should be
swap(&a[pindex],&a[end]);
pivot was a value, not an index.
Another change, you required quicksort,
if (start < end){
pindex = partition(a,start,end-1);
//As here index is one past last, so make it start..pindex
quicksort(a,start,pindex);
quicksort(a,pindex+1,end);
}
Your partition function should be
int partition(int a[],int start,int end){
int pivot = a[end];
int pindex=start;int i;
for ( i=start; i <= end-1; i++){
if (a[i] <= pivot){
swap(&a[i],&a[pindex]);pindex++;
}
}
swap(&a[pindex],&a[end]);
return (pindex);
}
See https://en.wikipedia.org/wiki/Quicksort#Lomuto_partition_scheme. This partition scheme is used here.

Answer 3

Your program fails if someone type negative numbers.
Why are you complicating things like that ?
Here is a simple sort:
#include <stdio.h>
void bubble_sort(int *array, int length){
int i,j, k, temp;
for (i = 0 ; i < length-1; i++){
for (k = 0 ; k < length-i-1; k++){
if (array[k] > array[k+1]){
temp = array[k];
array[k] = array[k+1];
array[k+1] = temp;
}
}
}
printf("The sorted Array List:\n\n");
for ( j = 0 ; j < length ; j++ ){
printf("%d ", array[j]);
}
}
int main(void){
int array[8] = {4, 3, 5, 2, 1, -1, 2, 3};
int length = sizeof array / sizeof array[0];
bubble_sort(array, length);
printf("\n");
return 0;
}
Output:
-1 1 2 2 3 3 4 5