import java.util.Arrays;

public class QuickMedian {

    private static void exchange(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    // Modified version of book's partition, where the median
    // of the first, last, and middle element is used as pivot.
    private static int partitionMedian(int[] a, int p, int r) {
	// Finds median and places as last element.
	int[] v = {a[p], a[(p+r)/2], a[r]};
	if (v[0] <= v[1] && v[1] <= v[2]) { // v[1] is median.
		exchange(a, ((p+r)/2), r);
	} else if (v[1] <= v[0] && v[0] <= v[2]) { // v[0] is median.
		exchange(a, p, r);
	}

	// Regular partition continues.
        int x = a[r];
        int i = p-1;

        for (int j = p; j < r; j++) {
            if (a[j] <= x) {
                i = i + 1;
		exchange(a, i, j);
            }
        }
	exchange(a, i+1, r);
        return i+1;
    }

    // See book.
    private static int partition(int[] a, int p, int r) {
        int x = a[r];
        int i = p-1;

        for (int j = p; j < r; j++) {
            if (a[j] <= x) {
                i = i + 1;
		exchange(a, i, j);
            }
        }
	exchange(a, i+1, r);
        return i+1;
    }

    // See book.
    private static void quickSort(int[] a, int p, int r) {
        if (p < r) {
    	    int q;
    	    if ((r-p+1) < 16) {
                	q = partition(a, p, r);
         	    } else {
                    q = partitionMedian(a, p, r);
    	    }
                quickSort(a, p, q-1);
                quickSort(a, q+1, r);
        }
    }

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

}