protected void recSelSort(int lastIndex, Comparable[] elts) { if (lastIndex > 0) // more than 1 element to sort { int extreme = 0; // index of element w/ largest value // Find "extreme", index of elts w/ largest value. for (int searchIndex = 1; searchIndex <= lastIndex; searchIndex++) { if (elts[extreme].lessThan(elts[searchIndex])) extreme = searchIndex; } // swap largest elt (at extreme) w/ one at lastIndex Comparable tempElt = elts[extreme]; elts[extreme] = elts[lastIndex]; elts[lastIndex] = tempElt; // elts[lastIndex] now largest in // elts[0..lastIndex] recSelSort(lastIndex-1,elts); // elts[0..lastIndex] are sorted. }
Example. Show by induction that
03 + 13 + 23 + ... + n3 = (0+1+2+ ... +n)2 Base. Show for n=0. 03 = 0 = (0)2 [Done.]
Inductive Hypothesis. Assume that for some n >= 0,
03 + 13 + 23 + ... + m3 = (0+1+2+ ... +m)2 , m <= n.
Induction Step. Show that 03 + 13 + 23 + ... + (n+1)3 = (0+1+2+ ... + n + n+1)2.
03 + 13 + 23 + ... + (n+1)3
= (0+1+2+ ... +n)2 + (n+1)3
= ((n)(n+1)/2)2 + (n+1)3
= ((n)(n+1)/2)2 + (n+1)2(n+1)
= ((n2 + n)/2)2 + n(n+1)2 + (n+1)2
= (n4 + 2n3 + n2)/4 + 4/4(n)(n+1)2 + (4/4)(n+1)2
= (n4 + 6n3 + 13n2 + 12n + 4)/4
= (n2 + 3n + 2)2/4
= ((n+1)(n+2)/2)2
= (0 + 1 + 2 + ... + n + n+1)2
What does this have to do with recursion?
B. Show that if algorithm works correctly for all simpler (i.e., smaller) input, then will work for current input.
To show that the recSelSort algorithm given earlier is correct, we will
reason by induction on the size of the array (i.e. on lastIndex)
Base: If lastIndex <= 0 then at most one element in elts, and hence sorted - correct.Induction Hypothesis: Suppose works if lastIndex < n.
Induction: Show it works if last = n (> 0).
Loop finds largest element and then swaps with elts[lastIndex].
Thus elts[lastIndex] holds largest elt of list, while others held in elts[0..lastIndex-1].
Since lastIndex- 1 < lastIndex, know (by induction hypothesis) that
recSelSort(lastIndex-1,elts) sorts elts[0..lastIndex-1].Because elts[0..lastIndex-1] in order and elts[lastIndex] is >= all of them, elts[0..lastIndex] is sorted.
Base: n = 0 or 1, 0 comparisons and n*(n-1)/2 = 0.Finished proof.Induction hypothesis: Suppose recSelSort(k-1,elts) takes k*(k-1)/2 comparisons for all k < n.
Induction step: Show true for n as well.
Look at algorithm: Run algorithm on recSelSort(n-1,elts). Therefore, last = n-1.
Go through for loop "last" = n-1 times, w/ one comparison each time through.
Thus n-1 comparisons. Only other comparisons are in recursive call:
recSelSort(last-1,elts) where last = n-1.But by induction (since last < n), this takes last*(last-1)/2 = (n-1)*(n-2)/2 comparisons.
Therefore altogether have (n-1) + (n-1)*(n-2)/2 = (n-1)*2/2 + (n-1)*(n-2)/2
= (n-1)*(2 + n-2)/2 = (n-1)*n/2 = n(n-1)/2 comparisons.
Therefore RecSelSort takes O(n2) comparisons.
Note: Iterative version of SelectionSort is similar, but needs an extra for loop.
// pre: exponent >= 0 // post - Returns baseexponent public int fastPower(int base, int exponent) { if (exponent == 0) return 1 else if (exponent%2 == 1) // exponent is odd return base * fastPower(base, exponent-1) else // exponent is even return fastPower(base * base, exponent / 2) }
Base case: exp = 0, FastPower(base,0) = 1 = base0 -- correctShow FastPower(base,n) = basenSuppose FastPower(base,exp) = baseexp for all exp < n.
Two cases:
n is odd: FastPower(base,n) = base * FastPower(base, n-1)= base * basen-1 (by induction)
= basen
n is even: FastPower(base,n) = FastPower(base*base,n / 2)
= (base2)(n / 2) (by induction)
= basen (since n is even)