Recursive Methods CSE 1030 Consider the factorial function in - PowerPoint PPT Presentation

Recursive Methods CSE 1030 Consider the factorial function in maths: Yves Lesp´ erance 0! = 1 1! = 1 2! = 2 × 1 = 2 3! = 3 × 2 × 1 = 6 4! = 4 × 3 × 2 × 1 = 24 . . . Lecture Notes n ! = n × ( n − 1) × . . . × 1 (*) Week 8 — Recursion A simple Java method that uses a loop to compute the function is: public static int factorial(int n) { int prod = 1; for(int i = 1; i <= n; i++) prod = prod * i; Recommended Readings: return (prod); Van Breugel & Roumani Ch. 7 and Savitch Ch. 11 and Sec. 12.2 } 2 In mathematics, it is common to give a recursive definition to such functions: � 1 if n = 0 In contrast to (*), this definition precisely specifies n ! for arbitrarily large n ! = n × ( n − 1)! otherwise n ’s. Recursive definitions are also called inductive definitions. Notice that the function is mentioned on the right hand side of the definition! Yet it is not circular; we can use it to find the value of the This kind of approach is often used in computer algorithms and pro- function for any argument, e.g.: grams. We can write a Java method that computes n ! by recursion: 4! = 4 × 3! 3! = 3 × 2! public static int factorial(int n) 2! = 2 × 1! { if (n == 0) // base case 1! = 1 × 0! return (1); 0! = 1 else // n != 0 recursive case 1! = 1 × 1 = 1 return (n * factorial(n - 1)); 2! = 2 × 1 = 2 } 3! = 3 × 2 = 6 4! = 4 × 6 = 24 3 4

This is implemented using an execution stack which keeps track of what methods are called, what the values of their parameters/local variables are, and where the methods will resume. Here is a call trace of factorial(4) : factorial(4) calls factorial(3) With recursive methods, the execution stack will contain several entries factorial(3) calls factorial(2) factorial(2) calls factorial(1) for the same method, e.g. the recursive calls to factorial . factorial(1) calls factorial(0) factorial(0) returns 1 factorial(1) returns 1 * factorial(0) i.e. 1 When recursion is not allowed (as in Fortran), there can never be more factorial(2) returns 2 * factorial(1) i.e. 2 than one call of a method that is active. So storage for the local vari- factorial(3) returns 3 * factorial(2) i.e. 6 factorial(4) returns 4 * factorial(3) i.e. 24 ables of methods can be allocated at compile time (statically). But when recursion is allowed as in all modern languages , a stack must be used to accomodate an arbitrary number of calls. 5 6 Recursion: Definitions Proof of Correctness by Induction: E.g. factorial A procedure/method is recursive iff it calls itself from within its own Show base case is correct: factorial(0) returns 1 which is 0! ; body either directly or indirectly (e.g. method m1 calls method m2 which correct. calls m1 ). For recursive case, assume the recursive calls, if they terminate, are A recursive solution to a problem involves two components: correct, and prove that the recursive case is correct given this assump- tion. 1. a direct solution to some simple instances of the problem; these are called base cases ; So assume factorial(n-1) (if it terminates) correctly returns ( n − 1)! . 2. a solution to the general case of the problem that involves solving a simpler instance(s) of the problem and performing some opera- Then factorial(n) returns n * factorial(n-1) . tions on the result; this is called the recursive case . Since factorial(n-1) is correct by our assumption, n * factorial(n-1) = n ∗ ( n − 1)! , which is n ! . The measure of problem size you are using is what you are doing recursion over ; e.g. for factorial, it is n ; first thing you need for designing a recursive solution. So the recursive case is correct and thus the method is correct. 7 8

Proof of Termination: E.g. factorial A Combined Proof by Induction of Correctness and Termination: E.g. factorial Define the size of each invocation of the method. This must be a nat- We prove correctness and termination of the factorial method by in- ural number. duction on the value of the argument n . Then show that each recursive invocation has a smaller size than the 1) Base case n = 0 : then factorial(0) terminates and returns original invocation. 1 = 0! , which is correct. If this is the case the method must terminate. 2) For the recursive case: Assume that factorial(n) is correct and For factorial: terminates for all n ≤ k . This is the induction hypothesis . We must prove that that the method is correct for n = k + 1 . Let size ( factorial(n) ) = n . Then factorial(n) returns ( k + 1) ∗ factorial( k ) . factorial(n) only makes the recursive call factorial(n-1) . Since factorial( k ) is correct by our assumption, ( k +1) ∗ factorial( k ) size ( factorial(n-1) ) = ( n − 1) < size ( factorial(n) ) = n . = ( k + 1) ∗ k ! = ( k + 1)! . So for all natural numbers n factorial( n ) is correct and terminates. So the method terminates. 9 10 This can be translated directly into a recursive Java method: E.g. Computing Terms of Fibonacci Sequence Recursively public static int fibo(int n) { if (n == 0) The Fibonacci sequence can given a recursive definition as follows: return 0; else if (n == 1)  return 1; 0 if n = 0   fibo ( n ) = 1 if n = 1 else  fibo ( n − 1) + fibo ( n − 2) otherwise  return fibo(n - 1) + fibo(n - 2); } 11 12

Call trace for fibo(5) : Call tree for fibo(5) : fibo(5) calls fibo(4) fibo(4) calls fibo(3) [Draw on board] fibo(3) calls fibo(2) fibo(2) calls fibo(1) fibo(1) returns 1 fibo(2) calls fibo(0) fibo(0) returns 0 fibo(2) returns fibo(1) + fibo(0) i.e. 1 fibo(3) calls fibo(1) fibo(1) returns 1 fibo(3) returns fibo(2) + fibo(1) i.e. 2 fibo(4) calls fibo(2) fibo(2) calls fibo(1) fibo(1) returns 1 fibo(2) calls fibo(0) fibo(0) returns 0 fibo(2) returns fibo(1) + fibo(0) i.e. 1 fibo(4) returns fibo(3) + fibo(2) i.e. 3 13 14 Problem: Write a recursive version of a method isPalindrome(String word) that returns true iff word is a palin- drome, i.e. reads the same backwards and forwards; e.g. noon and dad are palindromes. fibo(5) calls fibo(3) fibo(3) calls fibo(2) fibo(2) calls fibo(1) fibo(1) returns 1 fibo(2) calls fibo(0) fibo(0) returns 0 fibo(2) returns fibo(1) + fibo(0) i.e. 1 fibo(3) calls fibo(1) fibo(1) returns 1 fibo(3) returns fibo(2) + fibo(1) i.e. 2 fibo(5) returns fibo(4) + fibo(3) i.e. 5 15 16

public static <T> boolean contains(T element, List<T> list) { boolean contains; if (list.size() == 0) Recursive Methods for List Processing { contains = false; } else E.g. a method contains(T element, List<T> list) that searches { if (element.equals(list.get(0))) list to see if element appears in it. { contains = true; } else Note that version below is more efficient than Van Breugel and Roumani’s { because doesn’t make copy of rest of list. List<T> rest = list.subList(1, list.size()); contains = MyClass.contains(element, rest); } } return contains; } 17 18 Proof of Correctness by Induction: If element is not equal to the first element of list , it is contained in Base case list.size() = 0: Correct, since element cannot be list iff it is contained in the rest of the list. contained in an empty list. In this case, the method return the result of a recursive call on the rest For recursive case list.size() ≥ 1 : of the list. By the induction hypotesis, this recursive call is correct (if it terminates). Induction hypothesis: Assume the recursive call, if it terminates, is correct. So if it terminates, the method returns the correct answer in the recur- sive case. list has at least one element. If element is equal to the first element of list we return true. Correct. 19 20

Proof of Termination Let size ( contains(element, list) ) = list.size() . Pitfalls of Recursion This is a natural number. 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 “ n == 0 ” in Show size of recursive invocation is smaller. factorial . Make sure you have enough base cases. list.subList(1, list.size()).size() < list.size() Anything that can be done using a loop can be done by recursion. So size ( contains(element, rest) ) < size ( contains(element, However, recursion can be less efficient than an iterative implementa- list) ). tion. This can happen because there is recalculation of intermediate results as in fibo . Or there can be extra memory use because recur- So the method terminates. sive calls must be stored on the execution stack, e.g. factorial . See other list processing examples in Van Breugel and Roumani. 21 22 Advantages of Recursion But some algorithms can be coded much more simply using recursion and there is no loss of efficiency. E.g., traversing a tree and printing the labels on the nodes. Another e.g.: Mergesort algorithm to sort an array/collection. Also some types of recursion do not require the use of additional stack memory and good compilers can take advantage of this. These tech- niques are studied in “functional programming” . 23