---
title: Eboard 37  An introduction to sorting
number: 37
section: eboards
held: 2017-11-27
---
CSC 151.03, Class 37:  An introduction to sorting
=================================================

_Overview_

* Preliminaries
    * Notes and news
    * Upcoming work
    * Extra credit
    * Questions
* The problem of sorting
* Writing sorting algorithms
* Some examples
* Formalizing the problem

### News / Etc.

* I hope you had a happy Thanksgiving.
* I've graded and returned exam 3. 
* Draft of exam 4 is released.

### Upcoming Work

* No writeup for today's class.
* Projects due Tuesday.
* Reading for Wednesday: [Sorting](../readings/sorting)
* [Exam 4](../exams/exam04) due in a week.

### Extra credit (Academic/Artistic)

* CS Table Tuesday: Unknown topic
* CS Extras Thursday: Unknown topic

### Extra credit (Peer)

* One acts Friday at 8pm and Saturday at 2pm and 8pm and Sunday at 2pm.

### Extra credit (Misc)

* Forum: A Community Responds — A Bias/Hate Incident Raising Issues of Free Speech and Inclusivity.  Tuesday, 11 a.m., Sebring-Lewis.
* Mental Health Campus Resource Fair.  Friday at 4pm in JRC 209.

### Other good things

* Swim meet this coming weekend.
* Jazz Ensemble Concert Friday at 7:30 p.m.
* Chamber Ensembles Saturday at 4:00 p.m.
* Collegium Concert Sunday at 2:00 p.m.

### Questions

The problem of sorting
----------------------

Early this semester, we taught you `sort`, which changes the order of the
elements in a list so that they are arranged from "smallest" to "largest".

It's a common problem

* Preparation for binary search.
* Find the median.
* Find the nth largest (or nth smallest)

Since it's a common problem, computer scientists have spent a lot of time
designing and studying sorting algorithms.

* About a dozen core sorting methods, each with variants.
* Potentially hundreds of different methods.

Writing sorting algorithms
--------------------------

A typical strategy

* Start by solving an example.
* Try to generalize.
* Try on another input
* Code
* Test
* Prove correct

Some examples
-------------

How would you put this group of students in order from smallest to 
largest?

### Strategy 1: Selection sort

* Find the smallest.  Put it at the front of a new list.
* Find the smallest remaining. Put it next.
* Find the smallest remaining.  Put it next.

If there are 10 elements, how many comparisons will our mentor do?

* 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 = 45

If there are n elements, how many comparisons will our mentor do?

* n-1 + n-2 + n-3 + .... + 3 + 2 + 1 = n(n-1)/2 or about n*n/2

* Key step: Select largest/smallest.

### Strategy 2: Insertion sort

* Turn the first element into a list.
* Add the next element to the right place in the list.
* Add the next element to the right place.
* Add the next element to the right place.

How do we find the right place?  

* Look at the elements one by one.
* We could use binary search to find the right place.  That's fast.
* Unfortunately, inserting is slow.

How long does that take?

* Insert the first element: 1 steps
* Insert the next element: 2 steps
* Insert the next element: 3 steps

Whoops, it's the same pattern for figuring out the cost.

Key step: Insert into a list.

### Strategy 3: Bubble sort

* Go through the list, and swap if two elements are out of order.
    * The largest is now at the end of the list.
* Then do it again
* And again
* And again
* Each time through, we do n-1 comparisons
* Potentially n-1 repetitions of the big thing
* So (n-1)*(n-1)

Key idea: Elements "bubble" to their correct position

Formalizing the problem
-----------------------

Let's document one of the versions of sort.

```
;;; Procedure:
;;;   list-sort
;;; Parameters:
;;;   lst, a list
;;;   may-precede?, a binary comparator
;;; Purpose:
;;;   sort the list
;;; Produces:
;;;   sorted, a list
;;; Preconditions:
;;;   * may-precede? should be applicable to any two elements in the list
;;;   * may-precede? must be transitive.  If `(may-precede? a b)` and
;;;     `(may-precede? b c)` then `(may-precede a c)`?
;;; Postconditions:
;;;   * sorted is a permutation of lst.
;;;   * For any index, i, 0 <= i < (- length 1),
;;;     `(may-precede? (list-ref lst i) (list-ref lst (+ 1 i)))`
```

How would the documentation change if we worked with vectors?

* We might make it mutate the vector instead of creating a new vector.
* We would change `list-ref` to `vector-ref`.
* We would use the name `vec` rather than `lst`.

What should we call the binary comparator?

* `pred?` - not very informative.
* `compare?` - a bit more informative.
* `may-precede?` - more informative  Given two values, tells you whether
  the first can precede the second.
* `less-than?` - clearer, except that we allow >

Making it better
----------------

All of the algorithms are O(n*n).

We improved linear search to binary search by "divide and conquer".

Can we similar improve one of our searching algorithms (perhaps by
limiting inputs)?