change pivot in my quickSort algorithm java

Question

I have implemented a working quickSort algorithm using the first element in the array as the pivot, that look like this:

public int[] quickSort( int[] a, int start, int end){

    int l = start;
    int r = end;

    int pivotIndex = start; //<---- first element in the array as pivot! 

    // must be at least two elements
    if ( end - start >= 1){

        // set pivot
        int pivot = a[pivotIndex];


        while ( r > l ){
            // scan from the left
            while ( a[l] <= pivot && l <= end && r > l  ){
                l++;
            }
            while ( a[r] > pivot && r >= start && r >= l){
                r--;
            }
            if ( r > l ){
                this.swap(a, l, r);
            }
        }
        this.swap(a, pivotIndex, r);

        System.out.println("calling quickSort on " + start + " and " + (r-1));                 
        quickSort(a, pivotIndex, r - 1); // quicksort the left partition
        System.out.println("calling quickSort on " + (r+1) + " and " + end);
        quickSort(a, r + 1, end);   // quicksort the right partition

    } else {
        return a;
    }

    return a;
}    

And this works nicely, but if I change the pivotIndex to lets say int pivotIndex = end; I get this result:

run:
2, 8, 7, 1, 3, 5, 6, 4, 
2, 8, 7, 1, 3, 5, 6, 4, 
swapping l:8 and r:4
2, 4, 7, 1, 3, 5, 6, 8, 
swapping l:7 and r:3
2, 4, 3, 1, 7, 5, 6, 8, 
swapping l:8 and r:1
calling quickSort on 0 and 2
calling quickSort on 4 and 7
2, 4, 3, 8, 7, 5, 6, 1, 
swapping l:7 and r:1
2, 4, 3, 8, 1, 5, 6, 7, 
swapping l:7 and r:1
calling quickSort on 4 and 3
calling quickSort on 5 and 7
2, 4, 3, 8, 7, 5, 6, 1, 
swapping l:5 and r:1
2, 4, 3, 8, 7, 1, 6, 5, 
swapping l:5 and r:1
calling quickSort on 5 and 4
calling quickSort on 6 and 7
2, 4, 3, 8, 7, 5, 6, 1, 
swapping l:6 and r:1
2, 4, 3, 8, 7, 5, 1, 6, 
swapping l:6 and r:1
calling quickSort on 6 and 5
calling quickSort on 7 and 7
2, 4, 3, 8, 7, 5, 6, 1, 
BUILD SUCCESSFUL (total time: 1 second)

How to I make the algorithm work with the pivotIndex as any index 0 to a.length

Answer 1

You could simply swap the pivot you chose with the first element in the array before you start sorting, that way it'll work exactly as before.

int l = start;
int r = end;

this.swap(a, choosePivot(), start); 
int pivotIndex = start; 

Answer 2

If you choose to start with pivoting on an arbitrary element you have to change the behavior of your partitioning loop. See the code below:

/* Selecting the pivot to be a random-ish element
   and pivotIndex to be beginning, since we don't know
   where it will be until we loop through the list */
int pivot = a[someInt];
int pivotIndex = begin-1;
//have to keep track of where the pivot actually is in the list
int currentPivotIndex = someInt;

for(int i = begin; i <= end; i++) {
    if(a[i] <= pivot) {
        //for each element less than the pivot
        //the pivotIndex moves by one
        pivotIndex++;
        //place the element to the left of the pivot
        this.swap(a, pivotIndex, i);
        //update currentPivotIndex if needed
        if(a[pivotIndex] == pivot) {
            currentPivotIndex = pivotIndex;
        }
    }
}
//put the pivot in its place
this.swap(a, pivotIndex, currentPivotIndex);

Answer 3

This is some odd behavior which is most probably caused by having your pivot element engage in partitioning.

The first line of the output says swapping l:8 and r:4 but it should have been swapping l:8 and r:3. Because 4 is the pivot element and it doesn't belong to the partition on the left, nor to the partition on the right. It's the element in the middle of the partitions. It has to be isolated during partitioning.

To fix this issue, after you select your pivot, move it to the end. I.e, first thing, replace pivot with the last element of the array. Therefore, you can isolate it from the partitioning process. Then start the while loop with l = start and r = end - 1 because end is currently pivot. Leave it alone. After you're done with partitioning, restore the pivot in the middle of the two partitions. The middle would be where l and r meet.

I believe following the above approach would fix your problem. Let me know if it doesn't.

Not directly related but your choice of the pivot element has a huge effect on the performance of quicksort. With its current version, hitting the worst-case (O(n^2)) is likely. Most simply, you can choose it randomly, which brings O(nlogn) complexity with high probability.