Recursion

• This is one of several topics we missed last fall.
  • We will spend a few days catching up.
• Recursion is a strange topic in some ways
  • It requires you to think about looping differently.
  • It is usually not the most efficient solution code wise.
  • But it is sometimes a really good way to think about a solution, ie build an algorithm.
• Something is recursive if it uses a copy of itself to solve a problem.
• There are multiple things in Mathematics that are defined recursively.
  • n! = n(n-1)! for n ≥ 1, 0!=1
    • This is called factorial
    • It is frequently used in counting and probability.
    • But it shows up other places.
    • Example

      4! = 4(4-1)! = 4 * 3!
                         3! = 3(3-1)! = 3 * 2!
                                            2! = 2 * 1!
                                                     1! = 1 * 0!
                                                              0! = 1 by definition
                                                        = 1 * 1  
                                                        = 1
                                            2! = 2 * 1
                                               =2
                         3! = 3 * 2 
                            = 6
      4! = 4 * 6 
         = 24 

  • The Fibonacci sequence is a sequence that appears frequently in mathematics.
    • The n^th number in the sequence is defined by
      • f(n) = f(n-1) + f(n-2) when n > 2;
      • f(n) = 1 when n = 1 or 2
      • f(n) = 0 when n = 0, this is sometimes omitted.
    • Examples:

      f(1) = 1
      f(2) = 1
      f(5) = f(4) + f(3)
             f(4) = f(3) + f(2)
                    f(3) = f(2) + f(1)
                         = 1 + 1
                         = 2
             f(4) = 2 + 1 
                  = 3
      f(5) = 3 + 2
           = 5 

• Note that in each of these cases
  • There was a stopping point or base case
  • The function was defined using the function being defined.
  • This is a recursive definition
  • The recursive definition made progress or got closer to the base case.
• There are many algorithms that are defined recursively
  • Binary search

    BinarySearch(A, begin, end, key)
    
     if begin >  end
        return NOT_FOUND 
     mid ← (begin+end)/2
     if A[mid] == key
        return mid
     else if A[mid] > key
        return BinarySearch(A,begin, mid-1, key)
     else
        return BinarySearch(A,mid+1,end,key)
     

• A = {1, 5, 9, 12, 15, 19}
• Do BinarySearch(0,4, 10)