# Quick sort with median-of-three partitioning : Sort « Collections « Java Tutorial

```public class MainClass {
public static void main(String[] args) {
int[] intArray = { 1, 9, 2, 8, 3, 7, 4, 6, 5 };
for (int i : intArray) {
System.out.println(i);
}
quickSort(intArray);
for (int i : intArray) {
System.out.println(i);
}
}

public static void quickSort(int[] intArray) {
recQuickSort(intArray, 0, intArray.length - 1);
}

public static void recQuickSort(int[] intArray, int left, int right) {
int size = right - left + 1;
if (size <= 3)
manualSort(intArray, left, right);
else {
double median = medianOf3(intArray, left, right);
int partition = partitionIt(intArray, left, right, median);
recQuickSort(intArray, left, partition - 1);
recQuickSort(intArray, partition + 1, right);
}
}

public static int medianOf3(int[] intArray, int left, int right) {
int center = (left + right) / 2;

if (intArray[left] > intArray[center])
swap(intArray, left, center);

if (intArray[left] > intArray[right])
swap(intArray, left, right);

if (intArray[center] > intArray[right])
swap(intArray, center, right);

swap(intArray, center, right - 1);
return intArray[right - 1];
}

public static void swap(int[] intArray, int dex1, int dex2) {
int temp = intArray[dex1];
intArray[dex1] = intArray[dex2];
intArray[dex2] = temp;
}

public static int partitionIt(int[] intArray, int left, int right, double pivot) {
int leftPtr = left;
int rightPtr = right - 1;

while (true) {
while (intArray[++leftPtr] < pivot)
;
while (intArray[--rightPtr] > pivot)
;
if (leftPtr >= rightPtr)
break;
else
swap(intArray, leftPtr, rightPtr);
}
swap(intArray, leftPtr, right - 1);
return leftPtr;
}

public static void manualSort(int[] intArray, int left, int right) {
int size = right - left + 1;
if (size <= 1)
return;
if (size == 2) {
if (intArray[left] > intArray[right])
swap(intArray, left, right);
return;
} else {
if (intArray[left] > intArray[right - 1])
swap(intArray, left, right - 1);
if (intArray[left] > intArray[right])
swap(intArray, left, right);
if (intArray[right - 1] > intArray[right])
swap(intArray, right - 1, right);
}
}

}
```
```1
9
2
8
3
7
4
6
5
1
2
3
4
5
6
7
8
9```
 9.53.Sort 9.53.1. Bubble Sort 9.53.2. Selection Sort 9.53.3. Insertion Sort 9.53.4. Sorting Objects using insertion sort 9.53.5. Mergesort: merging two arrays into a third 9.53.6. Generic Merge Sorter with generic Comparator 9.53.7. Shellsort 9.53.8. Quicksort: simple version of quick sort 9.53.9. Quick sort with median-of-three partitioning 9.53.10. Quick sort: uses an insertion sort to handle subarrays of fewer than 10 cells