Recursive Algorithms

• Recursion is the ability of an algorithm to call itself.
  • The principle is simple, yet complex.
  • It is not usually the best programming solution.
  • But it leads to some fairly simple algorithms.
• A recursive algorithm (function) must have three things.
  • It must have a base case where the recursion stops.
  • It must have a recursive case, where it calls itself
  • It must make progress or get closer to the base case.
• $n!$ is a mathematical function that is some times defined recursively.
  • For some non-negative integer n

  •               | 1  if n = 0 or n = 1
             n! = |
                  | n*(n-1)!   if n > 1

  • Calculate some factorials.
  • Write an algorithm
  • Calculate the factorials using the algorithm
• We can write a recursive binary search

  • BinarySearch(A, first, last, key) 
    
     if first >= last 
        return NOT_FOUND
     mid = (first + last)/2
     if A[mid] match the key
        return mid
     else if A[mid] is less than the key
        return BinarySearch(A, mid+1, last, key);
     else
        return BinarySearch(A, first, mid-1, key);
     

• We have parallel sorting algorithms
• Mergesort is the easiest one to understand
  • Split the array in the middle.
  • Mergesort the low half.
  • Mergesort the high half
  • Merge the two halves.
  • A video if you wish.

  • MergeSort(A, low, high) 
    
     if low >= high
       return
     mid = (low+high)/2
     MergSort(A, low, mid)
     Mergesort(A, mid+1, high)
     Merge(A, low, mid, high)
    
    
    Merge(A, low, mid, high) 
    
     while there is data in each sub list
        copy the smallest data value to the merged list
     Copy the data remaining in one of the lists to the merged list
    
             

  • This ends up begin $O(n log_2 n)$
  • But needs extra space to merge.
• One more sort: Quicksort
  • Big Idea
    • Pick a random element
    • Rearrange the array so the values less than the random element are on the low side and the other values are on the high side.
    • QuickSort the low side
    • QucikSort the high side.
  • The partition algorithm
    • Select the last element as the pivot value
    • Set pivot point to low-1
    • from the first element to the last-1
    • If the current element is less than the pivot value
    • increase the pivot location
    • swap the smaller element with the element at the pivot location
    • Put the pivot element in the pivot location
    • Return the pivot location

  • 
    l l l h h h u u u _   
    
    0 1 2 3 4 5 6 7 8
    2 0 3 9 7 6 5 1 8    pivot value = 4, pivot location = 3, current  = 6
                          
    

  • A more code like algorithm

  • QuickSort(A, low, high)
    
     if low < high
        pos = Partition(A, low, high)
        Quicksort(A, low, p-1)
        Quicksort(A, p+1, high)
    
    
    Partition(A, low, high)
    
     pivot = A[hi]
     pivotLoc = low-1
     for j = low to high-1 
       if A[j] <=  pivot
          i = i + 1
          swap(A[i],A[j]);
     i = i + 1
     swap (A[i], A[hi]
     return i