Divide And Conquer

• Divide/Conquer/Combine is perhaps a better way to put it.
• Divide the problem into subparts
• Solve each of the subparts.
• Combine the solution for the larger solution.

  • DIVIDE_AND_CONQUER_ADD(A,low,high)
    
     if low > high
         return 0
     else if  low = high
         return A[low]
     else
         mid ← (high+low)/2
         return DIVIDE_AND_CONQUER_ADD(A, low,mid) + DIVIDE_AND_CONQUER_ADD(A, mid+1, high)
    
        

  • Work?
  • Terminate?
  • Time?
• The master method:
  • Divide and conquer algorithms have a timing function:
  • T(n) = aT(n/b)+f(n)
    • f(n) ∈ Θ(n^d)
  • The master method tells us that
    • T(n) = Θ(n^d) if a < b^d
    • T(n) = Θ(n^dlog n) if a = b^d
    • T(n) = Θ(n^log_ba) if a > b^d
  • The proof of this is beyond the scope of this class.
  • Use this to analize DIVDE_AND_CONQUER_ADD

Mergesort

• MERGESORT(A[0... n-1])
  
  if n > 1
      B ← A[0 ... n/2-1]
      C ← A[n/2 ... n-1]
      MERGESORT(B)
      MERGESORT(C)
      MERGE(B,C,A)
  
        

• The merge algorithm

• MERGE(B[0 .. p-1],C[0 .. q-1], A[0 .. n-1])
  
   i ←0; j←0, k←0
  while i <p and j < q do
       ifB[i] ≤C[j] 
            A[k] ← B[i]; i←i+1
       else
            A[k] ← C[j]; j←j+1
       k ← k + 1
  if i == p
          copy(C[j .. q-1] to A[k .. n-1]
  else
          copy(B[i .. p-1] to A[k .. n-1]
  
        

• Note, frequently we stop when the array size is small.
  • Say 2^k or fewer elements.
  • Call a good O(n²) sort (Like insertion sort or selection sort at this point).
  • This eliminates quite a few recursive calls.
• There are other improvements to mergesort, which me mentions a few of in the last paragraph.