Recursion

• A recursive function is a function which calls it's self.
• Perhaps the place to start is a mathematical function
  • The Fibonacci sequence is normally defined as follows

                       |  1   if n = 1,2
    	     F(n) =|
    	           |  F(n-1) + F(n-2)  for n > 2
           

  • This sequence has various applications
  • Calculate F(4)

    F(4) = F(3) + F(2)                       F(2) = 1
                                             F(3) = F(2) + F(1)
    					         1   + 1 = 2
    F(4) =  2 + 1
           

  • Calculate F(6)

           F(6) = F(5) + F(4)              F(4) = 3 from above
                                           F(5) = F(4) + F(3) 
    				               3  + 2 = 5
           F(6) = 5 + 3 = 8
           

  • Note this might not be the best way to compute F(n), but more on that later.
• Some things to notice:
  • There is a base case n=1 or 2, where no recursion is needed.
  • There is a recursive case (n > 2) which employs the function to calculate the function.
• When implementing a recursive function, you need to keep these two parts in mind when implementing a recursive functions.

  // assume only positive input
  int Fib(int n) {
     int returnValue;
  
     // handle the base case first;
     if (n == 1 or n == 2) {
        returnValue = 1;
     } else {
        returnValue = Fib(n-1) + Fib(n-2);
     }
     return returnValue;
  }
  

• Let's look at a number of other computations from a recursive point of view.
  • The book suggests computing xⁿ for integer n> 0.
  • Let's try a mathematical definition first.
    • What are possible base cases? (n=0 or n = 1)
    • What is a recursive case (n > 1)
    • Can we give a general definition

                    |  1              n = 0
         Pow(x,n) = |  x              n = 1
                    |  x* Pow(x,n-1)  n > 1
         Pow(x,n) = |
      	    

    • Compute Pow(2,0), Pow(2,1), Pow(2,2), Pow(2,3), ...
    • Code
      • Note, in this case, I am gong to use multiple returns.

      • float Pow(float x, int n) {
             // base case number 1 
             if (n == 0) {
                return 1;
             // base case number 2
             } else if (n == 1) {
                 return x;
             // recursive case
             } else {
                 return x * Pow(x, n-1);
             }
        }
        

  • Another commonly recursively defined function is factorial.
    • For an positive integer n, n! = n*(n-1)!
    • The base case is 0! = 1

    •                   |  0                  n = 0
         factorial(n) = |
                        |  n*factorial(n-1)   n> 0
      
      	

    • implementation

      • long Factorial(int n) {
            if (n == 0) {
               return 1;
            }
            return n*Factorial(n-1);
        }
        

  • The general pattern for a recursive function is to ask "Can I solve this problem in terms of this problem?
    • Printing a string
      • How do you print an empty string?
      • How about a string that is not empty?
      • What would the base case be?
      • What would the recursive case be?

      • void PrintString(string s) {
           if (s.size() != 0)  {
               cout <<s[0];
               PrintString(s.substr(1,string::npos));
           }
           return;
        }
        

    • How about binary search?
      • Generally binary search is in the form
        • pos_t BinarySearch(array A, pos_t start, post_t stop, item_t key);
        • Where pos_t is probably an unsigned integer.
        • start is the first element of the array
        • stop is the last element of the array
        • item_t is the type of item we are looking for.
        • key is the data item we are searching for.
        • For now, we will deal with a string as the array.
        • Remember, the array must be sorted.
      • What is the general form of the algorithm?

      • find the middle element (start+stop)/2
        if the middle element matches the key
           return true, middle position, ....
        else if the key is less than the middle element
           return the results of a search of the lower half of the array
        else
           return the results of a search of the upper half of the array
               

      • What if the element is not in the array?
        • When will this happen? (element is not in the array)
        • When will we know this happens? (the array size becomes 0)
        • How will we know this (start > stop)
        • This constitutes another base case.

      • int BinarySearch(string s, int start, int stop, char key) {
            int mid;
            if (start > stop) {
                // we need some indication of not found
                return -1;
            } else {
                mid = (start + stop) /2;
        	if (s[mid] == key) {
        	   return mid;
        	} else if (key < s[mid]){
        	   return BinarySearch(s,start, mid-1, key);
        	} else {
        	   return BinarySearch(s,mid+1,stop, key);
        	}
            }
        }