Lecture 13: Prelim Review

Topics possibly covered on the preliminary exam: Lectures 1–12.

Read the lecture notes!

Topics:

Basic SML competence

• Primitive types (char, int, bool, real, string)
• Functions (higher-order, recursive)
• Tuples and records
• Structures, signatures, qualified names
• Pattern matching
• Datatypes and parameterized datatypes (options, lists, arrays)
• Imperative programming: side effects, refs, arrays, print, ;

Programming methodology

• Abstraction: by specification and by parameterization
• Modules
• Abstract datatypes
• Signature specifications
• Returns clauses
• Requires clauses
• Checks clauses
• Effects clauses
• Nondeterminism
• Implementation documentation
• Abstraction functions
• Commutation diagrams
• Representation invariants
• Reasoning about correctness
• Unit and integration testing
• Black-box and path-complete test cases

Data structures

• Set and map signatures
• Association lists
• Stacks and queues
• Binary search trees
• Red-black trees
• Hash tables

• Defining recurrence relations
• Solving recurrence relations
• Proofs by induction

Structure of test:

• Short answer questions
• 2 SML competence questions
• Module/ADT question
• Running-time analysis

Review

fun sort3(a: int list): int list =
  case a of
    nil => nil
  | [x] => [x]
  | [x,y] => [Int.min(x,y), Int.max(x,y)]
  | a => let
      val n = List.length(a)
      val m = (2*n+2) div 3
      val res1 = sort3(List.take(a, m))
      val res2 = sort3(List.drop(res1, n-m) @
                       List.drop(a, m))
      val res3 = sort3(List.take(res1, n-m) @
                       List.take(res2, 2*m-n))
    in
      res3 @ List.drop(res2,2*m-n)
    end

This algorithm actually does sort the list (I fixed it from the version given in class; the fix was to make sure the recursive sorts are applied to at least ceiling(2n/3) of the list.) But its run time is O(n^2.71), which we can show from the recurrence:

T(n) = kn + 3T(2n/3)

By plugging in cn² and cn³ for T(n), we find that cn² grows more slowly than T(n) and cn³ grows more quickly. If we solve for the exponent that lets us construct both upper and lower bounds, we find that it is log_3/23, or slightly less than 2.71!