CSC153 2004S, Class 23: Sorting

Admin:
* Two readings: Merge sort and Quicksort.
* Have a great weekend.  No new homework!
* Is "I don't plan to make it to my classes because I have too much homework" a  good excuse for missing class?  
  * (I do appreciate the notification, though.)
  * It's about prioritization: If your grade depends on a paper that has to get done, then you sometimes have to miss class.
  * Sam as teacher: Good students plan ahead.
  * Sam as human: Makes sense to me.

Overview:
* The "Batman" problem.
* Rephrasing and rewriting binary search without getkey.
* Designing algorithms.
* The problem of sorting.
* Two solutions: Insertion sort and merge sort.
* More time for searching lab (if there's time)

/The Batman Problem/
* Why does the following happen?
	> (binary-search "Batman" cartoons car string<?)
	3
	> (binary-search "Batman" cartoons car string<=?)
	-1
  * Request: Extend the code to see what happens?
  * Observation:
            (cond ((comes-before? key middle-key)
                   (search-portion lower-bound (- midpoint 1)))
    Says "If they're equal, throw away the middle element and recurse" (but only if comes-before? permits equality).
* Is that result acceptable? 
  * Unacceptable: 2
  * Acceptable: 1 (if the preconditions specify stuff well), 1, 1 (preconditions; would prefer that it did work)
* Can we rewrite binary search so that it accepts a <= predicate?
  * Need to check equality separately: If we want to check equality separately, we need an equality predicate.
  * Or ... (if (and (comes-before key midkey) (comes-before midkey key)) ...) (and preconditions that when comes-before is reflexive, the two values must be equal)

/How can we rewrite binary search without including get-key?/
* Could make the "what to match" parameter a procedure that accepts or rejects things
* Could make the comes-before? predicate extract the car.
* But how will it compare a procedrue (the "what to match" parameter) and a list?
* One possibility: "What to match" parameter can be a list (or whatever type the elements of the vector to search are)
* First: What would the "Search for Batman" call look like in such a procedure?
	(new-binary-search ("Batman", "???") cartoons
		(lambda (toon1 toon2)
                   (string<? (protagonist toon1) (protagonist toon2))))
* Conclusion: "It could be done, but it sounds painful."
  * Should I require it of those who missed class today?  No.

/On to algorithm design/
* Most of the algorithms we've looked at were designed already.
* How does one design a new algorithm? (Meta-algorithm: An algorithm for designing algorithms.  Or perhaps heuristics for designing algorithms.)
  * Sample problems: Salescritter X needs to visit N cities.  It knows the costs of flying between any pair of cities.  Find the cheapest way for it to visit all N cities and come home in the end.  It visits every non-home city EXACTLY ONCE.
* Heuristic one:
  * Ask so many questions about the problem that the creator abandons it.
* Heuristic two (The "greedy" algorithm)
  * Make a list of all possible paths, examine the cost of each, and find the smallest
  * Somewhat expensive: O(n!) close enough to O(2^n).  Too much!
  * More than the lifteime of the universe for 100 cities on a terraflop machine
* Develop a bad algorithm and look for possible improvements.

More realistic solutions
* Apply some traditional algorithm designs and see if they work
  * Greed - Given a choice, take the "best" one next
  * Exhaustive search - Try all possible solutions
  * Divide and conquer - Break the problem in half, solve each half, combine the solutions
  * We'll learn a few more
* Look at solutions to similar problems and see if you can modify them
* Do it by hand and reflect on what we did (the joy of play)

* This last one is a good way to solve the problem of sorting (given that we sort lots of things by hand anyway)

What is the problem of sorting?
* Informally: Given a collection of stuff, put it in order

;;; Procedure:
;;;   sort!
;;; Parameters:
;;;   vec, a vector
;;;   pred? a binary predicate
;;; Purpose:
;;;   Put the elements of vec into order.
;;; Produces:
;;;   Batman: Absolutely nothing.  (Modifies its parameter.)
;;; Preconditions:
;;;   pred? is a binary predicate.  (Well, Duh!)
;;;   pred? can be applied to any two elements of vec.
;;;   pred? is consistent: It must always return the same value when given the same parameters
;;;   vec must be sortable by pred? - There exists a permutation 
;;;   of the elements for which (pred? SEE BELOW) holds for every reasonable i.
;;; Postconditions:
;;;   vec is sorted: (pred? (vector-ref vec i) (vector-ref vec (+ i 1)))
;;;     holds for all reasonable i. 
;;;   The new contents of vec are a permutation of the old contents of vec.

For Monday:
* Can you write a "sorting procedure" that meets the postconditions but doesn't sort?
* Can you give input that makes sorting difficult or impossible?