Class 37: Exam 2

Held: Monday, 7 April 2003

Summary: Today we go over some of the key issues from exam 2.

Related Pages:

• EBoard.

Assignments:

• Think about what you know about inheritance for tomorrow.

Notes:

• I rearranged the syllabus so that we can talk about object-oriented design this week and about exam 2 today.
• Reminder: We meet in Saints' Rest tomorrow.
• Expect exam 3 on Friday.
• Are there questions on homework 3?

Overview:

• Quicksort.
• From Strings to Values.

Quicksorting Arrays

• Note: As I reviewed this, it looks like I didn't screw up.
• You still all get full credit.

Some Background

• How does the standard Quicksort procedure work?
  • It identifies a pivot value (often the first value in the list)
  • It splits the list into two parts: Those smaller than the pivot and those larger than the pivot.
• We'll need to do more or less the same thing for arrays, except that we won't build new arrays.
• How do we separate the array into parts? We'll do what we did with binary-search: use indices to keep track of the lower and upper bounds of the parts.

The Partition Code

• This procedure is clearly (or perhaps not so clearly) intended to do the split into two parts part.
• What are the four parameters?

  define partition!
    (let ((swap! (lambda (vec i j) 
                   (let ((tmp (vector-ref vec i)))
                     (vector-set! vec i (vector-ref vec j))
                     (vector-set! vec j tmp)))))
      (lambda (vec lower upper can-come-before?)
        (if (= lower upper)
            lower
            (begin
              (let kernel! ((l lower)
                            (u upper))
                (cond
                  ((= u l) 
                   (begin
                     (swap! vec lower u)
                     u))
                  ((not (can-come-before? (vector-ref vec u) 
                                          (vector-ref vec lower)))
                   (kernel! l (- u 1)))
                  ((can-come-before? (vector-ref vec l) 
                                     (vector-ref vec lower))
                   (kernel! (+ l 1) u))
                  (else (begin
                         (swap! vec l u)
                         (kernel! l u))))))))))
  

From String to Value