RUNNING TIME OF SELECTION SORT

protected static < T extends Comparable < T > > selectionSort(T a[]) {
    recSelectionSort(a, a.length-1);
}

protected static < T extends Comparable < T > > recSelectionSort(T a[], int lastIndex) {
    if (lastIndex > 0) {
        int max = 0;
        for (int i = 1; i <= lastIndex; i++) {
            if (a[i].compareTo(a[max]) > 0) {
                max = i;
            }
        }

        T tmp = a[lastIndex];
        a[lastIndex] = a[max];
        a[max] = tmp;
        recSelectionSort(a, lastIndex-1);
    }
}

INTUITION

Suppose we call recSelectionSort(a,n). That call will compare a[max] to a[1],a[2],...,a[n]. Thus, a total of n comparisions are performed. In addition, that method will call recSelectionSort(a,n-1). That recursive call will compare a[max] to a[1],a[2],...,a[n-1]. So, another n-1 comparisons occur. That recursive call will also call recSelectionSort(a,n-2), which will require n-2 comparisons, and so on until we call recSelectionSort(a,0), which will perform 0 comparisons.

The total number of comparisions is thus:

   n + (n-1) + (n-2) + ... + 2 + 1 + 0 = n * (n + 1) / 2.

PROOF

Theorem: recSelectionSort(a,n) requres n * (n + 1) / 2 comparisions.
By Induction on n:

Base case: If n = 0, then the code performs 0 comparisions, and
```
              0 = 0 * 1 / 2
```
Inductive Hypothesis: For all k < n, recSelectionSort(a,k) requires k * (k + 1) / 2 comparisions.
Inductive Step: We prove the theorem for n. recSelectionSort(a,n) performs n comparisons and calls recSelectionSort(a,n-1). By the Inductive Hypothesis, the recursive call requires (n - 1) * n / 2 comparisons. So, the total number of comparisons is
```
	      n + (n - 1) * n / 2 = (2n + (n - 1) * n) / 2   
				  = (2n + n * n - n) / 2
				  = (n * n + n) / 2
				  = (n + 1) * n / 2
```

Thus, for all n, recSelectionSort(a,n) requres n * (n + 1) / 2 comparisions.

In general, we say that sorting an array of size n with recSelectionSort requires O(n^2) time.

The running time of selectionSort on an array of size n is then also O(n^2).