415 lecture note #4

[Ch 3, 5.1] Algorithms (2)

3.4 Recursive Algorithms

• A recursive algorithm is an algorithm which invokes itself.
• A recursive algorithm looks at a problem backward -- the solution for the current value n is a modification of the solutions for the previous values (e.g. n-1).
• Basic structure of recursive algorithms:

  procedure foo(n) 1. if n satisfy some condition then // base case 2. return (possibly a value) 3. else 4. (possibly do some processing) 5. return (possibly some processing using) 6. foo(n-1) // recursive call

• Examples: 
  1. Factorial (n!)

     1! = 1
     2! = 1 * 2                      = 1! * 2
     3! = 1 * 2 * 3                  = 2! * 3
     n! = 1 * 2 * 3 * .. * (n-1) * n = (n-1)! * n

     • Recursive algorithm for factorial:

     Input: A positive integer n >= 0
     Output: n!

     procedure factorial(n)
     1. if n = 0 then
     2.   return 1                 // base case, 0! = 1
     3. return n * factorial(n-1)  // recursive call
     

     • Trace of procedure calls when n = 3

       factorial(3)
            factorial(2)
                 factorial(1)
                      factorial(0)
                      return 1
                 return 1 * 1 = 1
            return 2 * 1 = 2
       return 3 * 2 = 6
       

  2. Compound interest

     With an initial amount of $100 and 22 % annual interest, the amount at the end of the nth year, A_n, is expressed recursively as:

     

     • A general recursive algorithm for compound interest after n years (where n >= 0) with initial amount a and interest rate r is 

     procedure compound_interest(n, a, r)
     1. if (n == 0) then
     2.   return a
     3. return ((1 + r) * compound_interest(n-1, a, r))
     end compound_interest

     • Trace of procedure calls when n = 3

        

        

        

        

        

       
       

  3. Greatest Common Divisor (gcd)

     gcd(a, b) = gcd(b, a mod b), b > 0

     Recursive algorithm for gcd:

     Input: Integers a, b
     Output:  gcd(a, b)

     procedure recursive_gcd(a, b)
     1. if a < b then
     2.   swap(a, b)
     3. if b = 0 then                     // base case
     4.   return a
     5. return recursive_gcd(b, a mod b)  // recursive call
     

Proof of Correctness using Induction

• Correctness of a recursive algorithm is often shown using mathematical induction, due to the structural similarity -- base case and recursive/inductive case.
• Example: Factorial

  	procedure factorial(n)
  	1. if n = 0 then
  	2.   return 1                 // base case, 0! = 1
  	3. return n * factorial(n-1)  // recursive call

  Theorem: The algorithm factorial(n) outputs the value of n!, where n >= 0.

  Proof:

  Basic Step (n = 0):  In line 2, 0! = 1 is correctly outputted.

  Inductive Step:  Assume the algorithm correctly computes (n-1)!  for factorial(n-1).  Then for factorial(n), line 3 computes n * (n-1)! = n!, which is the correct value for factorial(n).

• NOTE:  The proof above uses "strong mathematical induction", which is defined as follows.

  Principle of Strong Mathematical Induction:  Let P(n) be a predicate that is defined for integers n, and let a and b be fixed integers with a <= b.  Suppose the following two statements are true: P(a), P(a+1),..,P(b) are all true. For all integers k >= b, if P(i) is true for all integers i with a <= i < k, then P(k) is true. Then the statement "For all integers n >= a, P(n)" is true.

  Notice here

  • k >= b >= a.  So when b != a, the inductive step starts from some number bigger than a.
  • P(k) -- not P(k+1) -- depends on all of P(a), P(a+1),.., P(b), P(b+1),..P(k-1).  In other words, the inductive hypothesis assumes PREVIOUS terms. 

More examples of recursive algorithms

• Usefulness of recursive algorithms
  • For some problems, it is difficult to derive explicit formulas directly.
  • Many computer programs have recursive functions because of the reason above.

• Example 1:  Fibonacci sequence

  

  f1	1
  f2	2
  f3	f2 +  f1 =
  f4	f3 +  f2 =
  f5	f4 +  f3 =

  Recursive algorithm for Fibonocci:

  Input: A positive integer n >= 1
  Output:  f_n

  procedure fibonocci(n)
  
  
  
  
  
  
  
  
  
  
  

   
• Example 2:  Tower of Hanoi problem (p. 228)

  There are 3 pegs, and n number of disks of various size are stacked in a peg, from the smallest disk at the top to the largest disk at the bottom.  How many moves are required to transfer those disks to another peg, if a disk can only be moved one at a time and a smaller disk can only be placed on a bigger disk???

  

  !! Web link to a Tower of Hanoi Puzzle !!

  C_n, the number of moves required to transfer n disks is expressed by a recursive relation:

  , where

  1) C_n-1 moves to transfer the top n-1 disks to the intermediate peg (say peg 2); 
  2) 1 move to transfer the bottom disk to the destination peg (say peg 3);
  3) C_n-1 moves to transfer  n-1 disks from the intermediate peg to the destination peg.