Understanding Recursion: Concepts, Rules, and Examples

1. Recursion Joe Meehean

2. Recursive Methods void g(){ ... h(); ... } void h(){ ... g(); ... } void f(){ ... f(); ... } • call themselves directly • or indirectly

3. Recursive Method Example int factorial(int x){ inthandback; if( x <= 1 ){ handback = 1; }else{ handback = x * factorial(x-1); } return handback; } factorial(4) = 4 * factorial(4 – 1) factorial(3) = 3 * factorial(3 – 1) … factorial(1) = 1

4. Conceptual Recursion • When a recursive call is made: • marks current place in code • clones itself • copy of code • new parameters • new set of uninitialized local variables • clone executes starting at beginning • When clone returns • clone is cleaned up • previous version starts at just afterrecursive method call

5. CLASS ACTIVITY void doClap(int k){ if(k == 0 ) return; clap k times; doClap(k – 1); return; } 1st person: doClap(3)

6. Incorrect Recursion void doClap(int k){ clap k times; doClap(k + 1); return; } • doClap(3) • 3, 4, 5, 6, … • memory access error • need code to stop recursion eventually

7. Recursion Rule 1 void doClap(int k){ if( k == 0 ) return; clap k times; doClap(k + 1); return; } • Still has infinite recursion? • Must have a base case • Condition under which no recursive call is made • Helps prevent infinite recursion

8. Recursion Rule 2 void doClap(int k){ if( k == 0 ) return; clap k times; doClap(k - 1); return; } • Does doClap follow rules 1 & 2? • Infinite recursion? • If so, how should we change the code Must make progress towards base case

9. Recursion Rule 2 void doClap(int k){ if( k <= 0 ) return; clap k times; doClap(k - 1); return; } • Does doClap follow rules 1 & 2? • Infinite recursion? • If so, how should we change the code Must make progress towards base case

10. Another Example void printStr(string s, int k){ if( k >= s.length() ) return; cout << s[k]; printStr(s, k+1); } printStr(“hello”, 0) => “hello” printStr(“hello”, 2) => “llo”

11. Recursion Rule 3 void printStr(string s, int k){ if( k >= s.length() ) return; cout << s[k]; printStr(s, k+1); } • Design rule • assume that all recursive calls work • even if you haven’t finished writing it yet

12. Another Example void printStr(string s, int k){ if( k >= s.length() ) return; cout << s[k] << endl; printStr(s, k+1); } printStr(“hello”, 0) h printStr(“hello”, 1) e printStr(“hello”, 2) l printStr(“hello”, 3) l printStr(“hello”, 4) o printStr(“hello”, 5)

13. Another Example void printStr(string s, int k){ if( k >= s.length() ) return; printStr(s, k+1); cout << s[k] << endl; } printStr(“hello”, 0) h printStr(“hello”, 1) e printStr(“hello”, 2) l printStr(“hello”, 3) l printStr(“hello”, 4) o printStr(“hello”, 5)

14. Understanding Recursion • A method may have statements • before recursive call • after recursive • both • After statements are done only • when the recursive call is finished • and all the recursive calls recursive calls have finished

15. DISCUSSION BREAK!!! void printStr(string s, int k){ if( k >= s.length() ) return; cout << s[k] << endl; printStr(s, k+1); cout << s[k] << endl; } Whats printed for printStr(“STOP, 0)?

16. DISCUSSION BREAK!!! void printStr(string s, int k){ if( k >= s.length() ) return; cout << s[k] << endl; printStr(s, k+1); cout << s[k] << endl; } • Whats printed for printStr(“STOP, 0)? • STOPPOTS • How can we change it to print • STOP<BREAK>POTS

17. DISCUSSION BREAK!!! void printStr(string s, int k){ if( k >= s.length() ){ cout << “<BREAK>” << endl; return; } cout << s[k] << endl; printStr(s, k+1); cout << s[k] << endl; } • How can we change it to print • STOP<BREAK>POTS

18. Questions?

19. Local Variables void mystery(int j){ if( j <= 0 ) return; intk = j * 2; mystery(j – 1); cout << k << “ “; } • Each clone gets own local variables • Outputs => 2 4 6

20. Recursive Call in Expressions // sums #s from 1 to max // Iterative version intdoSum(int max){ int sum = 0; for(inti = 1; i <= max; i++){ sum += i; } return sum; }

21. Recursive Call in Expressions // sums #s from 1 to max // Iterative version intdoSum(int max){ int sum = 0; for(inti = 1; i <= max; i++){ sum += i; } return sum; } // Recursive version intdoSum(int max){ if( max <= 0 ) return 0; return max + doSum(max – 1); }

22. Recursive Call in Expressions doSum(3) + 3 doSum(2) + 2 doSum(1) + 1 doSum(0)

23. Recursion in Practice • Can do recursion with int parameters • count up or down to base case • Or, with recursive data structures • a linked list is either empty • or a node followed by a linked list

24. Recursion in Practice void printList(Node<T> *node){ if( node == NULL ) return; cout << node->data << endl; printList(node->next); } Prints list in order

25. DISCUSSION BREAK!!! void printList(Node<T> *node){ if( node == NULL ) return; cout<< node->data << endl; printList(node->next); } How can we change this code to print list backwards?

26. DISCUSSION BREAK!!! void printList(Node<T> *node){ if( node == NULL ) return; printList(node->next); cout << node->data << endl; } Prints list backwards Rare case where recursion makes code faster as well as simpler

27. How does recursion really work? • Activation records (ARs) • stack of ARs maintained at runtime • 1 AR for each active method • active methods have been called, but not returned yet • Each AR includes: • function parameters • local variables • return address

28. How does recursion really work? • Activation Record Stack • when method is called, its AR is pushed • when method returns, its AR is popped • return address in popped AR tells program where to return control flow

29. Recursion Examples • Auxiliary recursion • wrapper method to do something ONCE before or after recursion • OR pass more parameters • recursion in auxiliary method • wrapper sometimes called a driver • Multiple recursive calls per method • need to recurse down a few different paths • more on this when we talks about trees

30. Example 1 // prints a header and the endline // calls aux to print the list void printList(Node<T> *node){ cout << “The list contains: “; printAux(node); cout << endl; } // prints a single string containing // each element in brackets void printAux(Node<T>* node){ if( node == NULL ) return; cout << “[“ << node->data << “]”; printAux(node->next); }

31. Example 2 // public method calls private method // with member variable int List::numNodes(){ return numAux(phead_); } // actually counts the nodes int List::numAux(Node<T>* node){ if( node == NULL ){ return 0; } return 1 + numAux(node->next); }

32. Example 3: Extra parameters intweirdSum(vector<int>& intVect){ return sumVector(intVect, 1); } // actually sums the entries intsumVector( vector<int>& intVect, intpos){ if( pos >= intVect.size() ) return 0; return intVect[pos] + sumAux(intVect, pos + 1); } Sum all elements in a vector but the first value

33. Example 4: Multi-recursive calls int fib(int n){ if( n <= 2) return 1; return fib(n – 2) + fib(n – 1); } • Fibonacci • fib(1) = 1, fib(2) = 1 • fib(N) for N > 2 = fib(N-1) + fib(N-2) • fib(3) = fib(2) + fib(1) = 1 + 1 = 2

34. Fibonacci Call Trace fib(4) 3 + 1 2 fib(3) fib(2) 2 + 1 1 fib(1) fib(2) Note: fib(2) is called twice Redoing work

35. Recursion Rule 4 • Compound interest rule • Never duplicate work • don’t solve the same recursive instance in separate recursive calls • repeats work you’ve already done • more on how to prevent this in CS242

36. Questions?

37. What good is it? • Recursion DOES NOT make your code faster • Recursion DOES NOT use less memory • Recursion DOES make your code simpler • sometimes

38. When is it a bad idea? • When you don’t get anything from it? • Tail recursion • the only recursive call is the last line • local variables stored just to be thrown away • Tail recursion can be replaced with a while loop

39. When is it a bad idea? void printStr(string s, int k){ if( k >= s.length() ) return; cout << s[k] << endl; printStr(s, k+1); } void printStrin(string s, int k){ while( true ){ if( k >= s.length() ) return; cout<< s[k] << endl; k = k + 1; } }

40. When is it a bad idea? void printString(string s, int k){ while( k < s.length()){ cout<< s[k] << endl; k = k + 1; } }

41. Recursion Rules Recap Base case Make progress Design rule Compound interest rule

42. Questions?