14 recursion
Download as PPT, PDF0 likes248 views
This document discusses recursion in programming. Recursion is when a function calls itself, either directly or indirectly. For a recursive function to work properly it must have a base case, which provides the terminating condition, and make progress toward the base case with each recursive call. Examples of recursively defined functions include factorials, powers, Fibonacci numbers, and towers of Hanoi. Recursion allows for simple programming of some complex problems but iterative solutions may have better performance due to less function call overhead.
14 recursion
- 2. Recursion Introduction Most mathematical functions are described by a simple formula C = 5 × (F – 32) / 9 It is trivial to program the formula Mathematical functions are sometimes defined in a less standard form ƒ(0) = 0 and ƒ(x) = 2ƒ(x-1) + x2 Then, ƒ(0) = 0, ƒ(1) = 1, ƒ(2) = 6, ƒ(3) = 21, … A function that is defined in terms of itself is recursive, and C allows recursive functions
- 3. Example Factorial: N! = N * (N-1)! Fibonacci Number: F(n) = F(n-1)+F(n-2) xn = x × xn–1 Tower of Hanoi
- 4. Example: factorial Example: factorials 5! = 5 * 4 * 3 * 2 * 1 Notice that 5! = 5 * 4! 4! = 4 * 3! ... Can compute factorials recursively using factorials Solve base case (1! = 0! = 1) then plug in 2! = 2 * 1! = 2 * 1 = 2; 3! = 3 * 2! = 3 * 2 = 6;
- 5. Factorial The following function computes n! recursively, using the formula n! = n × (n – 1)!: int factorial(int n) { int t; if (n <= 1) t=1; else t=n * factorial(n-1); return t; }
- 6. 5.13 Recursion 5! (a) Sequence of recursive calls. (b) Values returned from each recursive call. Final value = 120 5! = 5 * 24 = 120 is returned 4! = 4 * 6 = 24 is returned 2! = 2 * 1 = 2 is returned 3! = 3 * 2 = 6 is returned 1 returned 5 * 4! 1 4 * 3! 3 * 2! 2 * 1! 5! 5 * 4! 1 4 * 3! 3 * 2! 2 * 1!
- 7. Factorial() int factorial (int n) { | factorial(4) = int t; | 4 * factorial(3) = if (n <= 1) t = 1; /* BASE */ | 4 * 3 * factorial(2) = else t= n * factorial(n-1); | 4 * 3 * 2 * factorial(1) = return t; /* Make Progress */ | 4 * 3 * 2 * 1 = 24 }
- 8. Fundamental Rules of Recursion Base Case: Must have some base cases which can be solved without recursion Making Progress: for the case that are to be solved recursively, the recursive call always make progress toward the base case If you do not follow the above rule, your program would not terminate An Example of Non-Terminating Recursion int BAD (int x) { if (x==0) return (0); else return( BAD( x/3 + 1 ) + x–1 ); } main() { int y; y = BAD(1) + BAD(4);}
- 9. Recursion The following recursive function computes xn , using the formula xn = x × xn–1 . int power(int x, int n) { int res; if (n == 0) return 1; else{ res=x * power(x, n - 1); return res; } }
- 10. Recursion Both fact and power are careful to test a “termination condition” as soon as they’re called. All recursive functions need some kind of termination condition in order to prevent infinite recursion.
- 11. Recursive Functions: f(x)=2*f(x-1)+x2 A function that calls itself either directly of indirectly int f (int x) { if( x == 0 ) return (0); /* Base Case */ else return( 2*f(x-1) + x*x ); /* Make Progress*/ }
- 12. 5.14 Recursion Example: Fibonacci Series Fibonacci series: 0, 1, 1, 2, 3, 5, 8... Each number is the sum of the previous two Can be solved recursively: fib( n ) = fib( n - 1 ) + fib( n – 2 ) Code for the fibonacci function long fibonacci( long n ) { if (n == 0 || n == 1) // base case return n; else return fibonacci( n - 1) + // recursive step fibonacci( n – 2 ); }
- 13. 5.14 Example Using Recursion: The Fibonacci Series Set of recursive calls to function fibonacci f( 3 ) f( 1 )f( 2 ) f( 1 ) f( 0 ) return 1 return 1 return 0 return + +return
- 14. 5.15 Recursion vs. Iteration Repetition Iteration: explicit loop Recursion: repeated function calls Termination Iteration: loop condition fails Recursion: base case recognized Both can have infinite loops Balance between performance and software engineering Iteration achieves better performance (e.g., numerical computation) Why? Function call involves lots of overhead Recursion allows simple & efficient programming for complex problems, especially in non-numerical applications e.g., quick sort, depth first traversal, tower of hanoi, ….