Class 50: Quadratic Sorts

Held: Tuesday, May 3, 2005

Summary: Today we consider two of the common quadratic sorting methods: selection sort and insertion sort.

Related Pages:

• EBoard.
• Sample Code.

Overview:

• Testing sorting
• Bubble sort, and why not to use it
• Selection sort
• Insertion sort

Testing Sorts

• Suppose we've written a sorting algorithm.
• How do we decide whether or not it works?
• We might write a tester.
• The tester should do a variety of tests.
• The tester should check the results, rather than printing them, so that we don't have to rely on a human reading them.
  • If a test fails, we might print out results for analysis.
• What tests would you do?

Bubble Sort

• Bubble sort is bad. Don't use it.

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 write selection sort both recursively and iteratively.
• We can also write selection sort for lists (although "swapping" can be harder).

Insertion Sort

• One simple sorting technique is insertion sort.
• Insertion sort operates by segmenting the vector 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.
• The diagram is somewhat reversed from selection sort.

  +---+---+---+---+---+---+---+---+
  |   |   |   |   |   |   |   |   |
  +---+---+---+---+---+---+---+---+
                      |
       Sorted             Unsorted
  

• This may be likened to the way typical card players sort their hands.
• For vectors, inserting often requires shifting elements until we have a space at the correct place.
  • Since we have to keep track of the value being inserted, we swap with neighbors.
• For example

             SORTED       |  UNSORTED
      +---+---+---+---+---+---+---+---+
      | 1 | 3 | 6 | 8 | 9 | 2 | . | . |
      +---+---+---+---+---+---+---+---+
                            
  Inserting 2
      +---+---+---+---+---+---+---+---+
      | 1 | 3 | 6 | 8 | 9 | 2 | . | . |
      +---+---+---+---+---+---+---+---+
                            *
  Swap
      +---+---+---+---+---+---+---+---+
      | 1 | 3 | 6 | 8 | 2 | 9 | . | . |
      +---+---+---+---+---+---+---+---+
                        *
  
  Swap
      +---+---+---+---+---+---+---+---+
      | 1 | 3 | 6 | 2 | 8 | 9 | . | . |
      +---+---+---+---+---+---+---+---+
                    *
  
  Swap
      +---+---+---+---+---+---+---+---+
      | 1 | 3 | 2 | 6 | 8 | 9 | . | . |
      +---+---+---+---+---+---+---+---+
                *
  
  Swap
      +---+---+---+---+---+---+---+---+
      | 1 | 2 | 3 | 6 | 8 | 9 | . | . |
      +---+---+---+---+---+---+---+---+
            *
  
  Done
               SORTED         | UNSORTED
      +---+---+---+---+---+---+---+---+
      | 1 | 2 | 3 | 6 | 8 | 9 | . | . |
      +---+---+---+---+---+---+---+---+
            *
  

• We can now insert the value at the next position

      +---+---+---+---+---+---+---+---+
      | 1 | 2 | 3 | 6 | 8 | 9 | 7 | . |
      +---+---+---+---+---+---+---+---+
                                *
      +---+---+---+---+---+---+---+---+
      | 1 | 2 | 3 | 6 | 8 | 7 | 9 | . |
      +---+---+---+---+---+---+---+---+
                            *
      +---+---+---+---+---+---+---+---+
      | 1 | 2 | 3 | 6 | 7 | 8 | 9 | . |
      +---+---+---+---+---+---+---+---+
                        *
  Done                            |
      +---+---+---+---+---+---+---+---+
      | 1 | 2 | 3 | 6 | 7 | 8 | 9 | . |
      +---+---+---+---+---+---+---+---+
  

• How does our code differ for lists and arrays?