CSC153, Class 23: Sorting

Overview:
* The problem of sorting
* How to design a sorting algorithm
* Two standard sorting algorithms
* Lab (if there's time)

Notes:
* Questions on the homework?
* Questions on the reading on searching?
* Questions on anything?

----------------------------------------

Review:
* Sequential search
* Binary search
* Random search

If we're going to use binary search, we need our array
to be "in order".
* We need techniques for putting collections of stuff
  in order.
Why else to put things in order
* Aesthetics
* Permit humans to apply binary search or some variant
  thereof.
* Lets you group things.
* Lets you quickly select "top N"

Sam's technique for designing sorting (and other) algorithms
* Do it "by hand"
* Reflect on what you did
* Reflect on key aspects
* Encode in Scheme
* Cross your fingers or Formally analyze

Husker Du

Oge-Sort (Insertion Sort):
* Separate the stuff to sort into two parts
  + Things I haven't looked at yet
  + Things I've already put in order
* Repeatedly
  + Grab something you haven't looked at
  + Put it in the "correct" place in the ordered stuff

Running time?

  We grab something N times (1 step each)
  We put it in ordered stuff N times
    Find the appropriate place: log_2(n) using binary search
    Put it in the appropriate place: Stack of CD's: 1

Insertion sorting a pile of CDs is O(n*log_2(n))
* Fastest known speed for a sorting algorithm based on
  comparing elements: O(n*log_2(n))

What's the running time if the input is a list?
* Finding the appropriate place is O(n)
* Insertion is either O(1) or O(n)

;;; Precondition:
;;;   val is an integer
;;;   lst is a list of integers sorted in non-decreasing
;;;     order
(define insert
  (lambda (val lst)
    (cond ((null? lst) (cons val null))
          ((<= val (car lst)) (cons val lst))
          (else (cons (car lst)
                      (insert val (cdr lst)))))))

The <= should be a parameter.  THen we can insert into
any type of list.

If the input is a list, insertion sort is O(n*n)

What if the thing being sorted is a vector?
* Finding the correct place takes O(log_2(n))
* To insert into a vector, you need to shift stuff
  around.  Potentially O(n) stuff.

So insertion sort is O(n*(n+log_2(n)+c)) = O(n^2)

On average, the thing to insert is in the middle.

1/2 + 1 + 3/2 + 4/2 + 5/2 + ... n/2 = n*(n+1)/4
----

Other common technique: Selection sort
* Repeatedly select the largest or smallest and shove
  at the front.

----------------------------------------

Precondition for insert-string

  (string<=? (list-ref strings i) (list-ref strings (+ i 1)))
    "for all reasonable i"
    for 0 <= i < (- (string-length strings) 1)

How do we get time not to display the result?

> (let ((stuff (time (...))))
    (newline))

> (time (car (insertion-sort ...)))
----------------------------------------

Things in Sam's stack of CD's
* Husker Du: Classic Noise-Pop from Minneapolis (same
  period as the Replacements)
* Material Issue: Chicago-style Power Pop
* Ric Ocasek: Former Car's lead
* Michelle Shocked: Fun Folk
* Sonic Youth: Noise
* Vinal Avenue String Band: Boston Bluegrass