private int partition(int[] numbers, int left, int right) {
    int pivot = numbers[right];
    int i = left - 1;
    for (int j = left; j < right; ++j) {
      if (numbers[j] <= pivot) {
        swap(numbers, ++i, j);
      }
    }
    swap(numbers, ++i, right);
    return i;
  }
Quicksort (sometimes called partition-exchange sort) is an efficient sorting algorithm, serving
as a systematic method for placing the elements of an array in order. Developed by Tony Hoare
in 1959 and published in 1961, it is still a commonly used algorithm for sorting. When
implemented well, it can be about two or three times faster than its main competitors, merge
sort and heapsort.

Quicksort is a comparison sort, meaning that it can sort items of any type for which a
"less-than" relation (formally, a total order) is defined. In efficient implementations it is
not a stable sort, meaning that the relative order of equal sort items is not preserved.
Quicksort can operate in-place on an array, requiring small additional amounts of memory to
perform the sorting.

Mathematical analysis of quicksort shows that, on average, the algorithm takes O(n log n)
comparisons to sort n items. In the worst case, it makes O(n2) comparisons, though this
behavior is rare.
src/main/java/com/github/pedrovgs/problem80/QuickSort.java