Other Sorts

• Can we do something with non-comparison based sorts?
• Bucket Sort
• Assume we are gong to sort with keys between 0 and M-1, where M>2;

• (1) Create M empty bins, B[0] - B[M-1]
  (2) for each item in the list
  (3)      place the item into B[k], where k is the key
  (4) For i = 0 to M-1
  (5)    foreach item in B[i]
  (6)       remove item
  (7)       place it in next available space.
     

• Timing:
  • Clearly line 1 is O(M)
  • Line 2+3 are are O(n)
  • Line 4-7 is O(M+n)
  • Thus the entire algorithm is O(M+n)
  • Probably not good to sort 10 elements of range 0-99999
  • Probably good for 10,000 elements range 0 - 10,000
• Stable Sorting
  • A stable sort preserves the order in the array of two elements with the same value.
  • Example
    • sort {a, b, c, d, e, f}
    • Assume e < a = c = f < d < b
    • Result {e, a, c, f, d, b}
  • Bubble sort is stable (at least the one we looked at)
  • Bucket sort can be stable.
  • The other sorts we have looked at are not.
• Radix Sort
  • Assume our keys are d digit numbers.

  • (1) for i = 0 to d
    (2)   use any stable sort to sort on the digit  di
           

  • Example:

    328               321                101               101
    382               101                901               198
    321               901                321               321
    198  Sort on 1's  382 Sort on 10's   328 Sort on 100's 328
    899  ---------->  328 ------------>  382 ------------> 387
    101   place       198  place         198 Place         899
    901               899                899               901
           

  • Line 1 is O(d)
  • Line 2 is O(10+n) if we use the bucket sort
  • So the entire thing is O(d(n+10))
• An example sorting strings
• We have one more sort, but not yet.