University of Washington Computer Programming I Recursion Su00 tvi: Reverted to earlier version without mergesort code. Added explicit discussion of base vs recursive case, and making progress towards termination. Added Richard Anderson’s favorite “why does this terminate/we don’t know” example. Added explicit parallel between recursive mathematical definitions and recursive functions. Got rid of the inane recursive “insist on y or n” example. It’d be nice to have a non-numeric example, but it’s gotta be one that’s not contrived. Maybe best left to divide-and-conquer algorithms in CSE 143 © 2000 UW CSE

Overview Review Function calls in C Concepts Recursive definitions and functions Base and recursive cases

Factorial Function Factorial is an example of a mathematical function that is defined recursively, i.e., it is partly defined in terms of itself. Su00 tvi: Added. This seems to be a nice place to start, rather than just saying “a recursive function is one that calls itself” Students have seen definition by cases in their high-school math. I always bring this up to provide a bridge to something they already know. I think I may have found a program with a less intuitive interface than PowerPoint: the MS Equation Editor! Ugh!

Factorial Revisited We’ve already seen an implementation of factorial using a loop int factorial ( int n ) { int product, i ; product = 1 ; for ( i = n ; i > 1 ; i = i - 1 ) { product = product * i ; } return product ; Su00 tvi: Probably useful to have a reminder that we’ve been here before 1! is 1 2! is 1 * 2 3! is 1 * 2 * 3 4! Is 1 * 2 * 3 * 4 5! Is 1 * 2 * 3 * 4 * 5 . .

Factorial, Recursively But we can use the recursive definition directly to get a different version /* Compute n factorial – the product of the first n integers, 1 * 2 * 3 * 4 . . . * n */ int factorial(int n){ int result; if (n <= 1) result = 1; else result = n * factorial(n - 1); return result; } Su00 tvi: could return result directly, but it’s helpful to have a local variable for the (eventual) full trace. Style point: for a value-returning function, simply writing a description of that value in the heading coment is often sufficient - but there’s got to be a heading comment.

24 Trace factorial(4) = 4* factorial(3) = 4* 3 * factorial(2) = int factorial(int n){ int result; if (n <= 1) result = 1; else result = n * factorial(n - 1); return result; } 4* 3 * 2 * 1 = Su00 tvi: left this in - this is an “evaluation by substitution” trace. It gives an example of recursive evaluation without getting into stack frames or activation records. I think it’s useful to get across the notion of recursive evaluation in a nice, simple setting before we start to mess things up with implementation details. Animation added - click away to get the computation to unfold. Also tried to get a sense of the return values, which was not on the previous version of this slide. When I do this in class, I talk through the program step-by-step (“Is n<=1? No it’s not, so we need to calculate 3*factorial(3-1) or 3*factorial(2)…..” The function may be too small to be legible on TV, but they should have the handouts or previous slide, and putting the tiny version in adds some continuity. 4* 3 * 2 = 24 4* 6 =

What is Recursion? Definition: A function is recursive if it calls itself int foo(int x) { … y = foo(…); } Su00 tvi: This used to lead off the lecture with a couple of rhetorical questions. I think it works better here. How can this possibly work???

Function Calls Answer: there’s nothing new here! Remember the steps for executing a function call in C: Allocate space for called function’s parameters and local variables Initialize parameters Begin function execution Recursive function calls work exactly the same way New set of parameters and local variables for each (recursive) call Su00 tvi: Replaced previous review with repeat of the rules we used earlier to make it clear that nothing new is going on here. The only change is that we’re going to be executing the same code on a different set of variables.

Trace k main 24 24 n factorial result 24 4 6 n factorial result 6 3 2 int factorial(int n){ int result; if (n <= 1) result = 1; else result = n * factorial(n - 1); return result; } int main(void) { … k = factorial(4); ... k main 24 24 n factorial result 24 4 6 n factorial result 6 3 2 Su00 tvi: Animation added and things reformatted to fit on slide. The animation is pretty fine-grained. Each function call has allocation and parameter initialization separately. There is a separate display of the function result value before it is multiplied into the previous value of n and stored in result. n factorial result 2 2 n factorial result 1 1 1

Recursive & Base Cases A recursive definition has two parts One or more recursive cases where the function calls itself One or more base cases that return a result without a recursive call There must be at least one base case Every recursive case must make progress towards a base case Forgetting one of these rules is a frequent cause of errors with recursion Su00 tvi: new. Might want to amplify that the recursive call could be indirect - call a different function that eventually calls the original one - but I don’t want to clutter the slide further.

Recursive & Base Cases Base case Recursive case int factorial(int n){ int result; if (n <= 1) result = 1; else result = n * factorial(n - 1); return result; } Base case Recursive case Su00 tvi: new

Does This Run Forever? Check: Includes a base case? Yes Recursive calls make progress? Hmmm… int f (int x) { if (x == 1) return 1; else if (x % 2 == 0) return 1 + f(x/2); else return 1 + f(3*x + 1); } Answer: Not known!!! In tests, it always gets to the base case eventually, but nobody has been able to prove that this must be so! Su00 tvi: new. Animation: answer to second question is hidden at first. Open question for the mathematically minded.

3N + 1 function f(5) = 1 + f(16) = 2 + f(8) = 3 + f(4) = 4 + f(2) = 6 f(7) = 1 + f(22) = 2 + f(11) = 3 + f(34) = 4 + f(17) = 5 + f(52) = 6 + f(26) = 7 + f(13) = 8 + f(40) = 9 + f(20) = 10 + f(10) = 11 + f(5) = 12 + f(16) = 13 + f(8) = 14 + f(4) = 15 + f(2) = 16 + f(1) = 17

When to use Recursion? Problem has one or more simple cases These have a straightforward nonrecursive solution, and: Other cases can be redefined in terms of problems that are closer to simple cases By repeating this redefinition process one gets to one of the simple cases

Summary Introduced recursion Functions that call themselves Base and recursive cases Simple examples Factorial 3N + 1 function An important concept with many uses