Recursion

• Recursive code is self-referential.
• To be successful, recursive code should have the following properties
  • It should have a base case, or a case where you stop
  • It should have a recursive call that takes the calculation closer to the base case.
• Consider the Fibonacci sequence.
  • Write code to generate any number in this sequence.
  • Base case: n =1 or n = 2
  • Recursive case n > 2, F_n = F_n-1 + F_n-2
  • Notice in the recursive case, we get closer to the base case.

  • int fib(int n) {
        if (n < 1) {              // error check
           return -1
        } else if (n == 1) {         // base case 1
           return 1;
        } else if (n == 2) {         // base case 2
           return 1;
        } else {
           return fib(n-1) + fib(n-2);  // recursive call
        }
    }
    

  • Trace this by hand for = 6.
• Consider a search.
  • You have an orderd array of elements
  • You wish to determine if an item is in this list.
  • Consider:

    BinarySearch(A, start, end, element)
    
     if start ≥ end
         return false 
     mid <- (high + low) /2
     if A[mid] =  element 
        return true
     else if A[mid] > element
        return BinarySearch(A, start, mid-1, element)
     else 
        return BinarySearch(A, mid+1, end, element)
    
    

  • This search works as follows

    Look at the middle element, if this is it return success
    If the middle element is too large, search the bottom half of the list
    If the middle element is too small, search the top  half of the list
    

  • Trace this for the array {3,5,9,10,12,15}, find 12, 5 and 7
  • Can we argue that this algorithm is correct?

    By (Weak) Induction:
    
    Base:
       For a list of size 1, the midpoint will be that element
       we will find it, and thus return true or not find it
       and return false.
    
    Inductive Step:   Assume the binary search works for an 
                 array of size k.
    Next Case: Prove for k+1
    
        If we are searching a list of size k+1 we have three choices, 
        Either it is the midpoint, in which case we will return true
        Or it is in one of the two lists, each of which are roughly 
        of size k/2.   We know, by the genenral case that the search 
        will successfully work on any list smaller than k, so it will
        work on either of these two  lists.
    

• Consider a graphics example:
  • A picture is compsed of a series of dots or pixels.
  • Each pixel value is really just an integer (or three integers) in a range, 0-255 is common.
  • So the following would be a smiliy face

    0 0 0 0 0 0 0 0 0 0 0
    0 0 0 9 9 9 9 9 0 0 0
    0 0 9 0 0 0 0 0 9 0 0
    0 9 0 0 9 0 9 0 0 9 0
    9 0 0 0 0 0 0 0 0 0 9
    9 0 0 0 0 9 0 0 0 0 9
    9 0 0 9 0 0 0 9 0 0 9
    0 9 0 0 9 9 9 0 0 9 0
    0 0 9 0 0 0 0 0 9 0 0
    0 0 0 9 9 9 9 9 0 0 0
    

  • 
  • This image has been enlarged.
  • We might wish to change the colors of the image.
  • 
  • A common way to do this is a flood fill.
    • This requires an enclosed region, like the face.
    • Enclosed, look at 4 connected and 8 connected.
    • The user gives a point in the regioin they wish to fill, a fill color, and the original color.

      FloodFill(Picture, posx, posy, origColor, fillColor)
      
       if !Picture.valid(posx,posy)
          return
       if Picture.color(x,y) = origColor
          Picture.color(x,y) <- fillColor
          FloodFill(Picture, posx+1, posy, origColor, fillColor)
          FloodFill(Picture, posx-1, posy, origColor, fillColor)
          FloodFill(Picture, posx, posy+1, origColor, fillColor)
          FloodFill(Picture, posx, posy-1, origColor, fillColor)
      
      

• Recursion tends to be very expensive.
  • Consider the Fibonacci sequence for a large value of n.
  • What do we do when we evalueate this?
  • Consider the Ackermann function

    ACK(m,n)A
    
     if m=0
        return n+1
     else if m >0 and n = 0
        return ACK(m-1,1)
     else 
        return ACK(m-1, ACK(m, n-1))
    
    

  • Write the code to do this.
• Add a count to the fib code, to see how many times each value is evaluated.
• We can trade memory for speed through a process known as memoization
  • Recursion is generally bad when we recompute the same value over and over again.
  • If we come up with a way to save previously computed values, we can make our programs much quicker.

    Fib(n) 
    
     for i <- 1 to n do
        m[i] <-  ∞
     return MemFib(n)
    
    
    MemFib(n) 
    
     if m[n] != ∞ 
        return m[n]
     if n = 1 or n = 2
        rv <- 1
     else 
        rv <- MemFib(n-1) + MemFib(n-2)
     m[n] <- rv
     return rv
    
    

  • Try this memoized and nonmemoized for Fib(25).
• In general recursive functioins are not great for computing mathematical equations.
• Memoization mitegates this somewhat.
• But it is great for other types of problems.
• And we will use it as the semester goes along.