Class 52: Quadratic Sorts

Held: Friday, 2 December 2005

Summary: Today we consider two of the common quadratic sorting methods: selection sort and insertion sort. Both are quadratic in that their running time is O(n²)

Related Pages:

• EBoard.
• Sample Code.

Due

• Exam 3: Data Types and Data Structures

Overview:

• Bubble sort, and why not to use it.
• Selection sort.
• Insertion sort.
• Comparing these algorithms.

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 smallest of the unsorted elements, and swap it into the end of the sorted part. This swapping continues until there are no unsorted elements.
• Here's a potentially-helpful picture:

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

• Note that we can write selection sort both recursively and iteratively.
• We can also write selection sort for lists (although "swapping" can be harder).
• The running time is fairly easy to compute: For each position, we run through the vector finding the smallest remaining element. There are n positions and it takes O(n) steps to find the smallest element, so this is an O(n²) algorithm.

Insertion Sort

• Another 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 similar to that of 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 | . |
      +---+---+---+---+---+---+---+---+
  

• The running time is fairly easy to compute for the worst case: For each position we'll need to insert "at the front", so we swap with every neighboring element. There are n positions and it takes O(n) steps to find the smallest element, so this is an O(n²) algorithm. On average, it is also O(n²).

Comparing these Algorithms in the Real World

• Both of these algorithms are O(n²).
• Which should we use?
• If we look at number of steps, insertion sort seems to be faster (since we typically get about half-way through the elements before inserting, it takes about half as many steps).
• If we look only at number of swaps, selection sort is likely to be faster.