A lower bound for simple sorts

• Again, we will use the list 8 3 5 6 2 7 4
• An inversion is an ordered pair (i,j) such that i < j, but A[i] > A[j]
• (8,3), and (7,4) are some inversions in the list.
• But (8,5), (8,6) (8,2), (8,7), and (8,4) are inversions as well.
• In an ordered list, there are no inversions.
• For Insertion sort, Each inversion means a swap.

  InsertionSort(array, start, stop)
  
   for j = start+1 to stop
       key = array[j]
       i = j-1
       while i> 0 and  array[i] > key
           array[i+1] = array[i]
           i--
       array[i+1] = key
  
  

• Another analysis of the insertion sort may be as follows
  • Line 1 is O(n) and is performed regardless of the order of the data.
  • Let i be the number of inversions in the list.
  • Lines 2-7 are performed once for each inversion, thus are O(I)
• Thus Insertion sort is O(i + n)
• So how many inversions are in a list on average?
  • Assume there are no duplicate elements.
  • For each pair (x,y), let E be the event that x > y, or the pair is an inversion.
  • p(E) = 1/2
  • There are n(n+1)/2 such pairs, let this be S, the size of the sample space.
  • So, on average, the number of inversions (i) is, i = p(E) * S
  • i = n(n+1)/2 * 1/2 = n(n+1)/4
  • This is O(n²)
• So we can argue that any sort that swaps adjacent elements must be Ω(n²) on average.
• This is a lower bound, or the sort can't be any better than this.