Introduction to Recursion

Objectives

1. Discuss the basics of recursion.

Notes

• First we discussed the end of line problem between linux and windows.
  • Linux/unix only uses a \n
  • Windows uses a \r\n
  • Getline does not consume the \r
  • od -c filename will allow you to examine the file to see what format it is in .
  • dos2unix and unix2dos will convert between the two.
• A recursive function is a function that is defined using itself
• We discussed factorial (n!)
  • n! = n * (n-1) * (n-2) * ... * 3 * 2 * 1

  • 7! = 7*6*5*4*3*2*1
    6! =   6*5*4*3*2*1
    so
    7! = 7*6!
       = 7*(7-1)!
           

  • Or $n! = \begin{cases}n*(n-1)!, & n > 1\\ 1, & n =0,1\end{cases}$
  • We turned this into the following code:

    unsigned int Factorial(unsigned int n) {
        unsigned int answer{1};
        if (n > 1) {
           answer = n * Factorial(n-1);
        }
        return answer;
    } 

• We discussed integer powers.
  • If i is an integer, and n is not 0,
  • Or $n^i = \begin{cases}n*n^{i-1}, & i > 0\\ 1, & i =0\end{cases}$
• We discussed binary search
  • This is sometimes called the phonebook search.
  • This requires the data to be in order
  • To find a name in the phone book

  • Find(searchName, dataset);
    Find the middleName in the data set
       if the data set does not contain data
           return not found.
       if middleName == searchName 
          return found
       else if middleName > searchName
           //it is in the top half of the data set, 
           return Find(searchName, top half of the data set)
       else 
           return Find(searchName, bottom half of the data set) 

  • We will return to this.
• We discussed that our examples can be done with loops.
  • This is not true in general, we might also need a stack.
• We discussed the Flood Fill algorithm
  • If I have a map on a grid.
  • With a complete boundary
  • Flood fill at a point.

    FloodFill(map, x,y)
       if map[x][y] is valid and unfilled 
          make map[x][y] filled
          FloodFill(x+1,y);
          FloodFill(x-1,y);
          FloodFill(x,y+1);
          FloodFill(x,y-1);
           

• A recursive algorithm must
  • have a base case or non-recursive case
  • Have a recursive case
  • The recursive case must make progress towards the base case.