Data Structures

1. Data Structures R e c u r s i o n

2. Recursive Thinking • Recursion is a problem-solving approach that can be used to generate simple solutions to certain kinds of problems that would be difficult to solve in other ways • Recursion splits a problem into one or more simpler versions of itself

3. Recursion • Typically problems are solved by dividing into sub-problems • These sub-problems may also be divided into further smaller sub-sub-problems • When the sub-problems are small enough to solve directly the process stops. • A recursive algorithm follows the same technique by solving a given problem through solution oftwo or more easier to solve sub-problems • A recursive call is a function call in which the called function is the same as the one making the call.

4. Recursive Definitions • Recursion • Process of solving a problem by reducing it to smaller versions of itself • Recursive definition • Definition in which a problem is expressed in terms of a smaller version of itself • Has one or more base cases

5. Recursive Definitions • Recursive algorithm • Algorithm that finds the solution to a given problem by reducing the problem to smaller versions of itself • Has one or more base cases • Implemented using recursive functions • Recursive function • function that calls itself

6. Recursive Definitions • Base case • Case in recursive definition in which the solution is obtained directly • Stops the recursion • General case • Case in recursive definition in which a smaller version of itself is called • Must eventually be reduced to a base case

7. Recursion • Define an object in terms of itself • Consists of two parts • Recursive step • Base step f(n) = f(n-1) * n; f(1) = 1;

8. Outline of a Recursive Function if (answer is known) provide the answer else make a recursive call to solve a smaller version of the same problem base case recursive case -

9. Tracing a Recursive Function Recursive function • Has unlimited copies of itself • Every recursive call has • its own code • own set of parameters • own set of local variables

10. Tracing a Recursive Function After completing recursive call • Control goes back to calling environment • Recursive call must execute completely before control goes back to previous call • Execution in previous call begins from point immediately following recursive call

11. How Recursion Works • a recursive function call is handled like any other function call • each recursive call has an activation record on the stack • stores values of parameters and local variables • when base case is reached return is made to previous call • the recursion “unwinds”

12. 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. • This easily solved situation is called the base case. • Each recursive algorithm must have at least one base case, as well as the general case.

13. Designing Recursive Functions • Understand problem requirements • Determine limiting conditions • Identify base cases

14. Designing Recursive Functions • Provide direct solution to each base case • Identify general case(s) • Provide solutions to general cases in terms of smaller versions of itself

15. Steps to Design a Recursive Algorithm • There must be at least one case (the base case), for a small value of n, that can be solved directly • A problem of a given size n can be split into one or more smaller versions of the same problem (recursive case) • Recognize the base case and provide a solution to it • Devise a strategy to split the problem into smaller versions of itself while making progress toward the base case • Combine the solutions of the smaller problems in such a way as to solve the larger problem

16. Factorial 4! = 4 * 3 * 2 * 1 n! = n * (n-1) * … * 1 4! = 4 * 3! n! = n * (n-1)! factorial(n) = n * factorial(n-1)//recursive step factorial(1) = 1 //base step

17. Recursive Factorial Function int fact(int num) { if(num == 0) return 1; else return num * fact(num – 1); }

18. Execution Model for Factorial 1, if n = 0 n * (n-1)! if n > 0 n! = n 2 n 1 n 0 if( n <= 0) return 1; } else { return n * Fact(n - 1); } if( n <= 0) return 1; } else { return n * Fact(n - 1); } if( n <= 0) return 1; } else { return n * Fact(n - 1); } Fact(2)

19. Recursive Factorial Trace

20. Calling Stack Of Recursive Call int fact(int n){ if(n==1) return 1; else return (fact(n-1)*n); } Calling stack fact(n-1) fact(n)

21. Calling Stack int fact(int n){ //base step if (n == 1) return 1; //recursive step int temp = n * fact(n-1); return temp; } fact(4) = 4! = 24 Calling stack temp=1 temp=1 fact(1) n=1 temp=? temp=2 fact(2) n=2 temp=? temp=6 fact(3) n=3 temp=24 temp=? fact(4) n=4

22. 1 for n == 1 fib(n) = 1 for n == 2 fib(n-2) + fib(n-1) for n>2 Another Recursive Definition Fibonacci sequence: 1, 1, 2, 3, 5, 8, 13, 21, ….

23. Fibonacci Numbers 0, 1, 1, 2, 3, 5, 8, 13, … Fib(n) = Fib(n-1) + Fib(n-2) Fib(0) = 0 Fib(1) = 1 Recursive case Base case

24. fib (4) : 3 fib (3) : 2 fib (2) : 1 fib (0) : 0 fib (2) : 1 fib (1) : 1 fib (1) : 1 fib (0) : 0 fib (1) : 1 Recursive Fibonacci repeats computations

25. int power(int k, int n) { // raise k to the power n if (n == 0) return 1; else return k * power(k, n – 1); } Evaluating Exponents Recursively

26. Recursion or Iteration? • Two ways to solve particular problem • Iteration • Recursion • Iterative control structures: uses looping to repeat a set of statements • Tradeoffs between two options • Sometimes recursive solution is easier • Recursive solution is often slower

27. Recursion Versus Iteration • In iteration, a loop repetition condition determines whether to repeat the loop body or exit from the loop • In recursion, the condition usually tests for a base case • You can always write an iterative solution to a problem that is solvable by recursion • Recursive code may be simpler than an iterative algorithm and thus easier to write, read, and debug

28. When to use recursion? • if recursive and iterative algorithms are of similar efficiency --> iteration • if the problem is inherently recursive and a recursive algorithm is less complex to write than an iterative algorithm --> recursion • recursion very inefficient when values are recomputed

29. Efficiency of Recursion • Recursive methods often have slower execution times when compared to their iterative counterparts • The overhead for loop repetition is smaller than the overhead for a method call and return • If it is easier to conceptualize an algorithm using recursion, then you should code it as a recursive method • The reduction in efficiency does not outweigh the advantage of readable code that is easy to debug

30. Pitfalls of Recursion • One pitfall of recursion is infinite regress, i.e. a chain of recursive calls that never stops. E.g. if you forget the base case. Make sure you have enough base cases. • Recursion can be less efficient than an iterative implementation. This can happen because there is recalculation of intermediate results. • There can be extra memory use because recursive calls must be stored on the execution stack.