Quick sort logic - sorting

Question

I am trying to implement quick sort in java and I have one doubt. So here's my quick sort code:
package com.sorting;
public class QuickSort implements Sort {
#Override
public int [] sort(int[] arr) {
return quickSort(arr, 0, arr.length - 1);
}
private int [] quickSort(int[] numbers, int low, int high) {
if (low < high) {
int q = partitionTheArrayAroundPivot(numbers, low, high);
if (low < q)
quickSort(numbers, low, q);
if ((q+1) < high)
quickSort(numbers, q + 1, high);
}
return numbers;
}
private int partitionTheArrayAroundPivot(int[] numbers, int low, int high) {
int pivot = selectPivot(numbers, low, high);
int i = low;
int j = high;
while (true) {
while (numbers[i] < pivot) {
i++;
}
while (numbers[j] > pivot) {
j--;
}
if ( i <= j) {
swap(numbers, i, j);
i++;
j--;
} else {
return j;
}
}
}
private int selectPivot(int[] numbers, int low, int high) {
return numbers[high];
}
private void swap(int[] numbers, int i, int j) {
int temp = numbers[i];
numbers[i] = numbers[j];
numbers[j] = temp;
}
}
Doubt 1: We keep increasing the index i till we hit a number which is >= pivot
while (numbers[i] < pivot)
i++;
Similarly we keep decreasing the index j till we hit a number which is <= pivot
while (numbers[j] > pivot)
j--;
So, this means that both indexes will also come out of the loop if both hits pivots at two different places e.g. 1,0,1 here if pivot is 1, then i will be 0 and j will be 2. And the below condition will be satisfied
if (i <= j) {
....
}
but in that case it won't be able to sort the above array (1,0,1) because after swapping we are increasing i and decreasing j so the value become i = j = 1. After that i will hit the third element i.e 1 and will again come out of the loop with value i = 2 and similarly j = 0 and we will not be able to sort the array.
So where's the problem? Am I missing something?

Answer 1

I would rewrite the code a little so that selectPivot returns the index instead:
private int selectPivotIndex(int[] numbers, int low, int high) {
return high;
}
Then the partitioning funcion can move the pivot aside, and sort the remaining items according to pivot value. A single loop will do it, in this implementation duplicate pivots will end up on right side:
private int partitionTheArrayAroundPivot(int[] numbers, int low, int high) {
int pivotIndex = selectPivotIndex(numbers, low, high);
swap(numbers, pivotIndex, high); // Not needed if selectPivotIndex always returns high
int newPivotIndex = low;
for(int i = low; i < high; i++)
{
if(numbers[i] < numbers[pivotIndex])
{
swap(numbers, i, newPivotIndex);
newPivotIndex++;
}
}
swap(numbers, newPivotIndex, pivotIndex);
return newPivotIndex;
}
Finally, a small adjustment needs to be done in the quickSort method so that we don't end up in an eternal loop:
if (low < q)
quickSort(numbers, low, q - 1);
This approach is IMHO easier to understand and debug, hope it works for you.

Answer 2

Use
while (numbers[i] <= pivot) and
while (numbers[j] >= pivot) and your code will work