Held: Monday, 27 April 2015

Back to Outline 47 - Pause for Breath. On to Outline 49 - Insertion Sort.

Summary

We explore the problem of sorting. When you sort a list, vector, or other collection, you put the elements in order. The order of the elements usually corresponds to the type of the elements. We might sort strings alphabetically, grades numerically, colors by brightness, and so on and so forth.

Related Pages

• Morning EBoard 48 (Source a.m. 48)
• Afternoon EBoard 48 (Source p.m. 48)

Overview

• The problem of sorting.
• Writing sorting algorithms.
• Examples: Insertion, selection, etc.
• Formalizing the problem.

Administrivia

• New partners!
• Review session tonight at 7pm.
• Quiz 12 returned.
  
  • If you have questions, go to the review session tonight (or talk to me, or talk to a turo, or email me)
• Today is another discussion-style day.

Upcoming Work

• Projects due tomorrow night. Read the instructions!
• Exam 4 assigned, due next Monday.
  • Prologue due Friday night!
• No lab writeup.
• Reading for Tuesday: Sorting

Extra Credit Opportunities

Academic

• Toward an Embodied Libreal Arts, Tonight, 8pm, JRC 101
• PBK Convo, Wednesday.

Peer Support (Morning Section)

• KY's radio show, "We Think We're Funny", 9-10pm Mondays (TONIGHT).
• Julia's radio show, "The Hot Box". Wednesday night/Thursday morning 1:00-2:00 a.m.
• Baseball, Saturday, Noon and 2:30, Sunday 10:00 and 12:30.

Peer Support (Afternoon Section)

• Baseball, Saturday, Noon and 2:30, Sunday 10:00 and 12:30.

Miscellaneous

Other Good Things (no extra credit)

Notes on the Exam

• Electronic due Monday, printed due Tuesday.
  • Gives me time to try to get you grades sooner.
  • Experience shows most class have work due later in the week.
  • I will discuss extension.
• Starts with a pre-set Racket file to make it easier for you and for me.
• Seven problems, as always.
• Four problems are on a new model of trees.

Notes on the Project

• Yes, separate helpers are a good idea for development. 4Ps suffice, as does reasonable shorthand.
• Make sure to review the requirements, including the rubric.
• Scaling is essential. Stretching (switching aspect ratios) may be needlessly difficult.
  
  • If your images don't stretch, DOCUMENT IT!
  • If your images look better at certain aspect ratios, NOTE IT!

The Problem of Sorting

• As we saw recently, one problem that seems to crop up a lot in programmming (and elsewhere) is that of sorting.
• The problem: Given a list, array, vector, sequence, or file of comparable elements, put the elements in order.
  • In order typically means that each element is no bigger than the next element. (You can also sort in decreasing order, in which case each element is no smaller than the next element.)
• We'll look at techniques for sorting vectors and lists.

Designing Sorting Algorithms

• I suggest that you think about the development of sorting algorithms in Scheme similarly to the way you think about writing many algorithms.
• Start by thinking about the way you might do it by hand.
  • We may find a few different ways to sort by hand.
  • We'll probably leave the Scheme-ification to the end.
• Generalize what you're doing.
  
  • What is the "philosophy" of your technique?
  • What are the key steps.
• Come up with some initial test cases.
• Consider whether there are any deficiences to your technique.
• Decide on your parameters (e.g., are you sorting a list or a vector).
• Translate your algorithm into Scheme.
• Test test test.

Sample Sorting Algorithms

=== Insertion Sort

• One simple sorting technique is insertion sort.
• Insertion sort operates by segmenting the list into unsorted and sorted portions, and repeatedly removing the first element from the unsorted portion and inserting it into the correct place in the sorted portion.
• This may be likened to the way typical card players sort their hands.
• How might we code this recursively?
• Does our code differ for lists and arrays?

=== Selection Sort

• Selection sort is among the simpler and more natural methods for sorting vectors.
• In this sorting algorithm, you segment the vector into two subparts, a sorted part and an unsorted part. You repeatedly find the largest of the unsorted elements, and swap it into the beginning of the sorted part. This swapping continues until there are no unsorted elements.
• Here's a potentially-helpful picture: +---+---+---+---+---+---+---+---+ | | | | | | | | | +---+---+---+---+---+---+---+---+ | Unsorted Sorted
• Note that we can also write selection sort iteratively.

A More Formal Description

• Before implementing these algorithms, let's take a look at the way we might document one (or all) of the procedures
  • Purpose?
  • Parameters?
  • Produces?
  • Preconditions?
  • Postconditions?
• Here are some postconditions I typically think about:
  • You also need to ensure that all elements in the original list are in the sorted list.
  • You also need to ensure that no other elements are in the list.