Merge Sort

• Another Divide and conquer sort.
  • Divide - somehow split the data into portions.
  • Conquer - solve the sub problems.
  • Reassemble - put it back together.
  • For quicksort there was no reassembly cost
  • This is one possible method for designing a new algorithm.
• Merge Sort algorithm
  • Idea
    • Divide - split the array at the middle into two sub arrays
    • Conquer - sort the two sub arrays
    • Reassemble - put the two sub arrays back
  • Divide into two arrays
    • If there is 0 or 1 element the array is sorted.
    • If there is more than one element, split at start+int(start-end/2)
  • Conquer
    • Sort each of the subarrays.
  • Reassemble
    • To merge

      While a list is not empty
         Select the lowest first element
         remove it from the sub-list 
         place it in the available slot in the new list
      Place all of the remaining elements in the target list.
      
      

  • Final Algorithm

    
     Procedure mergesort(A,start,end)
    (1)    if (start < end-1) {
    (2)       split = start+(end-start)/2
    (3)	  mergesort(A,start,split)
    (4)	  mergesort(A,split+1,end)
    (5)	  merge(A,start,split,end)
           }
    
    

• Correctness:
• Complexity:
  • Time
    • T(n) = 2T(n/2) + n = O(nlg(n))
    • Best, average, and worst.
  • Space:
    • We need to have space to merge the two lists back into one.
    • We can't do this in place in O(n)
      • We might end up moving all n/2 items of the first list to the second half of the array
      • Each of these moves is an O(n), and we would do it n/2 times
      • So this would be O(n²)
      • Consider { 6, 7, 8, 9, 1, 2, 3, 4}
    • So we need twice the space in which to reassemble the array.
    • This is the first example of an algorithm that is not "in-place" ie it uses extra memory (more than O(1)) to perform the sort.
    • In this case, the memory requirement is O(n).