Merge Sort

• Idea: Split the list in half, sort each half, merge the two lists
• Split: Just at the midpoint
• Sort the two lists: Use mergesort

  MergeSort(array, start, stop) 
  
   if start < stop
       mid=(start+stop/2)
       MergeSort(array, start, mid)
       MergeSort(array, mid+1, stop)
       Merge(array, start, mid, stop)
  
  

• This is T(n) = 2T(n/2) + T(merge)

   
  Merge(array, start, mid, stop) 
  
   n1 = mid-start +1
   n2 = stop - mid
   L = new[n1]
   R = new[n2]
   for i= 1 to n1
       L[i] = array[start+i-1]
   for i = 1 to n2
       R[i] = array[mid+i]
   L[n1+1] = inf
   R[n2+1] = inf
   i = 1
   j = 1
   for k = start to stop 
      if L[i] < R[j]
         array[k]=L[i]
         i = i + 1
      else
         array[k] = R[j]
         j = j + 1
   delete L
   delete R
  
  

• Note, lines 9 and 10 are not strictly necessary, but they make lines 13-19 much easier.
  • We could (in O(n) time) search for the largest number in the list, and make inf that +1.
  • Actually, we can do this in O(1), since the max values are at array[mid] and array[stop]
  • The inf values are never copied to the array.
  • This also accounts for the extra size arrays in 3 and 4.
• This will produce a routine that is O(n), both time and space.
• Thus the performance of MergeSort is

  T(n) = 2T(n/2) + C(n)
  

• This is an example of divide and conquer
  • We split the data into halves
  • We sort each half
  • We combine the results.
  • This is the typical pattern for divide and conquer.
    • Divide the problem into sub-problems
    • Conquer each sub-problem, usually recursively
    • Combine the solutions from the sub-problems to solve the main problem.
  • Note at the conquer phase, we might not have to recurse
    • We could, when the data is small enough, perform another sort.
  • Divide and conquer often yields lg results.
  • This is essentially what we did in binary search.
  • We will use this technique again.
  • It is a valuable tool that you should remember.