Comp215: More Recursion

Size: px

Start display at page:

Download "Comp215: More Recursion"

Marshall Richard
5 years ago
Views:

3 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2);

4 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2);

5 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

6 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

7 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

8 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

9 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

10 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

11 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

12 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

13 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

14 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

15 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

16 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

17 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

18 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4)

19 Traditional, simple recursion class Fibonacci { return fib(n-1) + fib(n-2); fib(4) Runtime is exponential in n, clearly not the way to go.

20 Should we use mutation? class Fibonacci2 { if (n == 0 n == 1) return 1; int p1 = 1; int p2 = 1; for (int i = 2; i <= n; i++) { int oldp1 = p1; p1 = p2; p2 = oldp1 + p2; return p2; Runtime is O(n), so it s efficient, but is it correct?

21 No mutation!

22 Recursive Fibonacci, linear runtime class Fibonacci3 { return helper(1, 1, 1, n); private static int helper(int p1, int p2, int current, int goal) { if(current == goal) return p2; return helper(p2, p1+p2, current+1, goal);

23 Recursive Fibonacci, linear runtime class Fibonacci3 { return helper(1, 1, 1, n); private static int helper(int p1, int p2, int current, int goal) { if(current == goal) return p2; return helper(p2, p1+p2, current+1, goal);

24 Recursive Fibonacci, linear runtime class Fibonacci3 { return helper(1, 1, 1, n); helper(1,1,1,5) private static int helper(int p1, int p2, int current, int goal) { if(current == goal) return p2; return helper(p2, p1+p2, current+1, goal);

25 Recursive Fibonacci, linear runtime class Fibonacci3 { return helper(1, 1, 1, n); private static int helper(int p1, int p2, int current, int goal) { if(current == goal) return p2; return helper(p2, p1+p2, current+1, goal); helper(1,1,1,5) helper(1,2,2,5)

26 Recursive Fibonacci, linear runtime class Fibonacci3 { return helper(1, 1, 1, n); private static int helper(int p1, int p2, int current, int goal) { if(current == goal) return p2; return helper(p2, p1+p2, current+1, goal); helper(1,1,1,5) helper(1,2,2,5) helper(2,3,3,5)

27 Recursive Fibonacci, linear runtime class Fibonacci3 { return helper(1, 1, 1, n); private static int helper(int p1, int p2, int current, int goal) { if(current == goal) return p2; return helper(p2, p1+p2, current+1, goal); helper(1,1,1,5) helper(1,2,2,5) helper(2,3,3,5) helper(3,5,4,5)

28 Recursive Fibonacci, linear runtime class Fibonacci3 { return helper(1, 1, 1, n); private static int helper(int p1, int p2, int current, int goal) { if(current == goal) return p2; return helper(p2, p1+p2, current+1, goal); helper(1,1,1,5) helper(1,2,2,5) helper(2,3,3,5) helper(3,5,4,5) helper(5,8,5,5)

29 Recursive Fibonacci, linear runtime class Fibonacci3 { return helper(1, 1, 1, n); private static int helper(int p1, int p2, int current, int goal) { if(current == goal) return p2; return helper(p2, p1+p2, current+1, goal); helper(1,1,1,5) helper(1,2,2,5) helper(2,3,3,5) helper(3,5,4,5) helper(5,8,5,5)

30 Recursive Fibonacci, linear runtime class Fibonacci3 { return helper(1, 1, 1, n); private static int helper(int p1, int p2, int current, int goal) { if(current == goal) return p2; return helper(p2, p1+p2, current+1, goal); helper(1,1,1,5) helper(1,2,2,5) helper(2,3,3,5) helper(3,5,4,5) helper(5,8,5,5) This is tail recursion: helper returns a call to itself, no need to come back and do more computation.

31 Why tail-recursion instead of a loop? Easier to convince yourself it s correct Awkward juggling of variables as you change them Versus all values marching in lock step In functional programming languages not called Java, this is efficient Tail call optimization works well, but it s not in the Java virtual machine After 1000 s to s of Java stack frames, you ll run out of memory Footnote: Java9 might have tail call optimization. IBM s J9 JVM apparently has it. Many languages that run on the JVM (Scala, Ceylon, Kotlin, etc.) have it. So what should we do in Java? First, write it in a dumb-but-correct way. Build test cases. Next, if necessary, rewrite with tail-recursion. Verify test cases. Next, if necessary, rewrite as a loop. Verify test cases.

32 fold-right, revisited Fold-right: 1 + (2 + (3 + (4 + (5 + (6 + (7 + 8)))))) class GList<T> { public T foldr(binaryoperator<t> operator, T accumulator) { return operator.apply(value, taillist.foldr(operator, accumulator)); class Empty<T> extends GList<T> { public T foldl(binaryoperator<t> operator, T accumulator) { return accumulator;

33 fold-right, revisited Fold-right: 1 + (2 + (3 + (4 + (5 + (6 + (7 + 8)))))) class GList<T> { public T foldr(binaryoperator<t> operator, T accumulator) { return operator.apply(value, taillist.foldr(operator, accumulator)); Not tail-recursive. apply can t happen until foldr returns. class Empty<T> extends GList<T> { public T foldl(binaryoperator<t> operator, T accumulator) { return accumulator;

34 fold-left, revisited Fold-left: ((((((1+2) + 3) + 4) + 5) + 6) + 7) + 8 class GList<T> { public T foldl(binaryoperator<t> operator, T accumulator) { return taillist.foldl(operator, operator.apply(accumulator, value)); class Empty<T> extends GList<T> { public T foldr(binaryoperator<t> operator, T accumulator) { return accumulator;

35 fold-left, revisited Fold-left: ((((((1+2) + 3) + 4) + 5) + 6) + 7) + 8 class GList<T> { public T foldl(binaryoperator<t> operator, T accumulator) { return taillist.foldl(operator, operator.apply(accumulator, value)); Tail-recursive! apply happens first, then recursion. class Empty<T> extends GList<T> { public T foldr(binaryoperator<t> operator, T accumulator) { return accumulator;

36 Solving the problem in Java foldl can be rewritten as a loop; foldr cannot. So, yes, we ll use mutation, but only to do what the tail-recursive code did. And we ll verify our test cases all along. (And clever programmers will use foldl when possible, since we ll promise that it will be fast.)

37 Live coding Rewriting foldl to use iteration Rewriting other list methods to use foldl Reversing a list with a helper function Generalizing foldl from using a binary operator to a binary function Reversing a list with foldl

Data Structures And Algorithms

Data Structures And Algorithms Recursion Eng. Anis Nazer First Semester 2016-2017 Recursion Recursion: to define something in terms of itself Example: factorial n!={ 1 n=0 n (n 1)! n>0 Recursion Example: