Recursion : Chapter 8 Saurav Karmakar

1. Recursion : Chapter 8Saurav Karmakar

2. Recursive Function Call • a recursion function is a function that either directly or indirectly makes a call to itself. • but we need to avoid making an infinite sequence of function calls (infinite recursion)

3. Finding a Recursive Solution • A recursive solution to a problem must be written carefully • The idea is for each successive recursive call to bring you one step closer to a situation in which the problem can easily be solved • The easily solved situation is called the base case • Each recursive algorithm must have at least one base case, as well as a general (recursive) case

4. Mathemetical Induction To prove • Let p(n) denote the statement involving the integer variable n. The Principle of Mathematical Induction states: • If p(1) is true and, for some integer K >=1 , p(k+1) is true whenever p(k) is true then p(n) is true for all n>=1 . • 4 steps in using Induction: • Base cases; --- p(1), p(2), … • Induction hypothesis (IH); --- assume p(k) is true • Statement to be proved in induction; --- it is true for p(k+1) • Induction step. --- prove p(k+1) is true based on IH

5. A recursive defination int s (int n) { if (n ==1) return 1; else return s(n-1) + n; } • A few of problems: • n  0 at the beginning; • return value might be too large to fit in an int.

6. Printing number in Any Base const string DIGIT_TABLE = "0123456789abcdef"; const int MAX_BASE = DIGIT_TABLE.length( ); void printIntRec( int n, int base ) { if( n >= base ) printIntRec( n / base, base ); cout << DIGIT_TABLE[ n % base ]; } • Potential problems in this code: • if base>16: --- out of bound; • if base = 0: --- division by 0; • if base = 1: --- infinite loop.

7. General format forMany Recursive Functions if (some easily-solved condition) // base case solution statement else// general case recursive function call

8. When a function is called... • A transfer of control occurs from the calling block to the code of the function--it is necessary that there be a return to the correct place in the calling block after the function code is executed; this correct place is called the return address • When any function is called, the run-time stack is used--on this stack is placed an activation record for the function call

9. Stack Activation Frames • The activation record contains the return address for this function call, and also the parameters, and local variables, and space for the function’s return value, if non-void etc. • The activation record for a particular function call is popped off the run-time stack when the final closing brace in the function code is reached, or when a return statement is reached in the function code. • At that time the function’s return value, if non-void, is brought back to the calling block return address for use there

10. A Stake of Activation Records

11. A recursive function int Func ( /* in */ int a, /* in */ int b ) { int result; if ( b == 0 ) // base case result = 0; else if ( b > 0 ) // first general case result = a + Func ( a , b - 1 ) ) ; // instruction 50 return result; }

12. Run-Time Stack Activation Recordsx = Func(5, 2);// original call at instruction 100 FCTVAL ? result ? b 2 a 5 Return Address 100 original call at instruction 100 pushes on this record for Func(5,2)

13. record for Func(5,2) Run-Time Stack Activation Recordsx = Func(5, 2);// original call at instruction 100 FCTVAL ? result ? b 1 a 5 Return Address 50 FCTVAL ? result 5+Func(5,1) = ? b 2 a 5 Return Address 100 call in Func(5,2) code at instruction 50 pushes on this record for Func(5,1)

14. record for Func(5,1) record for Func(5,2) Run-Time Stack Activation Recordsx = Func(5, 2);// original call at instruction 100 call in Func(5,1) code at instruction 50 pushes on this record for Func(5,0) FCTVAL ? result ? b 0 a 5 Return Address 50 FCTVAL ? result 5+Func(5,0) = ? b 1 a 5 Return Address 50 FCTVAL ? result 5+Func(5,1) = ? b 2 a 5 Return Address 100

15. Run-Time Stack Activation Recordsx = Func(5, 2);// original call at instruction 100 FCTVAL 0 result 0 b 0 a 5 Return Address 50 FCTVAL ? result 5+Func(5,0) = ? b 1 a 5 Return Address 50 FCTVAL ? result 5+Func(5,1) = ? b 2 a 5 Return Address 100 record for Func(5,0) is popped first with its FCTVAL record for Func(5,1) record for Func(5,2)

16. Run-Time Stack Activation Recordsx = Func(5, 2);// original call at instruction 100 FCTVAL 5 result 5+Func(5,0) = 5+ 0 b 1 a 5 Return Address 50 FCTVAL ? result 5+Func(5,1) = ? b 2 a 5 Return Address 100 record for Func(5,1) is popped next with its FCTVAL record for Func(5,2)

17. Run-Time Stack Activation Recordsx = Func(5, 2);// original call at instruction 100 FCTVAL 10 result 5+Func(5,1) = 5+5 b 2 a 5 Return Address 100 record for Func(5,2) is popped last with its FCTVAL

18. Too much recursion Can Be Dangerous Fibonacci numbers. Long fib (int n) { If (n <=1) return n; Else return fib(n-1) + fib(n-2); }

19. Recursive Trace for Fibonacci Numbers

20. Too much Recursion Can be Dangerous • This definition will lead to exponential running time. • Reason: -- too much redundant work. • Not necessary to use recursion.

21. Tree • Tree is a fundamental structure in computer science. • Recursive definition: A tree is a root and zero or more nonempty subtrees. • Nonrecursive definition: A tree consists of s set of nodes and a set of directed edges that connect pairs of nodes. That is, a connected graph without loop.

22. Some more examples: • Factorials • Binary Search template <class Comparable> int binarySearch( const vector<Comparable> & a, const Comparable & x, int low, int high ) { if( low > high ) return NOT_FOUND; int mid = ( low + high ) / 2; if( a[ mid ] < x ) return binarySearch( a, x, mid + 1, high ); else if( x < a[ mid ] ) return binarySearch( a, x, low, mid - 1 ); else return mid; }

23. Divide and Conquer • Given an instance of the problem to be solved, split that into several, smaller, sub-instances (of the same problem). • Independently solve each of the sub-instances and then combine the sub-instance solutions so as to yield a solution for the original instance.

24. Finding ‘Greatest Common Divisor’ • gcd(A,B) = gcd(A-B, B) • template <class HugeInt> HugeInt gcd (const HugeInt &a, Const HugeInt &b ) { if( b==0 ) return a; else return gcd(b, a%b); }

25. Recursion or Iteration? CLARITY EFFICIENCY