Announcements. Recursion and why study it. Recursive programming. Recursion basic idea

Size: px

Start display at page:

Download "Announcements. Recursion and why study it. Recursive programming. Recursion basic idea"

Lee Harris
5 years ago
Views:

1 Announcements Recursion and why study it Tutoring schedule updated Do you find the sessions helpful? Midterm exam 1: Tuesday, April 11, in class Scope: will cover up to recursion Closed book but one sheet, both sides, of A4 paper is allowed Today s topic: recursion Reading: My notes and Chapter 5 Break around 11:45am A recursive function is a function that calls itself A different way of thinking of problems another problem solving approach to add to your repertoire Can solve some kinds of problems better with recursion than with iteration Leads to elegant, simplistic, short code (when used well) Many programming languages ("functional" languages such as Scheme, ML, Haskell, etc.) use recursion exclusively (no loops) A key component of the rest of our assignments in CSE Recursion basic idea Recursive programming A recursive function calls itself repeatedly with simpler and simpler subproblems until a trivial base case is reached There are 2 key components to a recursive function: 1. the base case, and 2. the recursive decomposition A leap of faith or an assumption is often needed that the simpler subproblem will be solved for you Example: clones of yourself where each clone solves a simpler problem than the previous clone There must be a base case for which there s a simple answer The base case is how the recursive function stops calling itself and begins to unwind 3 There must a recursive decomposition which breaks down the original problem into simpler problems of the same form The recursive decomposition must make progress towards the base case If it doesn t, then you have infinite recursion which will most likely result in a stack overflow! 4 1

2 Recursive pattern Pseudo code: define recursivefunction (parameters) { if (basecasecondition) { // base case compute base solution without recursion // recursive decomposition decompose problem into smaller subproblems call recursivefunction for each of the subproblems reassemble solutions into a solution for the whole Function vs. process Function is a static entity iterative function recursive function Process is a dynamic entity is defined to be a program in action iterative process recursive process 5 6 Iterative factorial fact1: public static int fact1 (int n) { int f = 1; for (int i = 1; i <= n; i++) { f = f * i; return f; Process of computing fact1(6) fact1(6) -> 720 ß Stack trace (Note: only 1 stack frame) 7 8 2

Recursive factorial fact2: Visualizing recursion: fact2(4) public static int fact2 (int n) { if (n == 1) { // base case return 1; // recursive decomposition return n * fact(n - 1); Winding!

3 Recursive factorial fact2: Visualizing recursion: fact2(4) public static int fact2 (int n) { if (n == 1) { // base case return 1; // recursive decomposition return n * fact(n - 1); Winding! call fact2(4) call fact2(3) call fact2(2) call return 4*6=24 final answer Return 3*2=6 return 2*1=2 return 1*1=1 Unwinding! Note: this is an example of linear recursion fact2(1) fact2(0) call return Process of computing fact2(6) Recursive factorial yet again fact2(6) -> 6 * fact2(5) -> 6 * (5 * fact2(4)) -> 6 * (5 * (4 * fact2(3))) -> 6 * (5 * (4 * (3 * fact2(2)))) -> 6 * (5 * (4 * (3 * (2 * fact2(1))))) -> 6 * (5 * (4 * (3 * (2 * 1)))) -> 6 * (5 * (4 * (3 * 2))) -> 6 * (5 * (4 * 6)) -> 6 * (5 * 24) -> 6 * 120 -> 720 ß Stack trace ß 6 frames on the stack at this point in time but with much deferred computation to be done fact3: public static int fact3 (int n) { return fact3aux(n, 1); private static int fact3aux (int n, int result) { if (n == 1) { return result; return fact3aux(n 1, n * result); fact2 is a recursive function with recursive shape of process

4 Process of computing fact3(6) More on Factorial and Fibonacci fact3(6) -> fact3aux(6, 1) -> fact3aux(5, 6) -> fact3aux(4, 30) -> fact3aux(3, 120) -> fact3aux(2, 360) -> fact3aux(1, 720) -> 720 ß Stack trace ß 6+1 frames on the stack at this point in time but without any deferred computation to be done See Fact.java Be sure to read the comments in Fact.java fact3 is a recursive function with iterative shape of process Recursive sum Write a recursive function to find the sum of all the elements in an integer array First version: sum public static int sum(int[] a) { return sumaux(a, a.length); private static int sumaux(int[] a, int n) { if (n == 0) { return 0; return a[n-1] + sumaux(a, n-1);

5 Another version: sum1 Yet another version: sum2 public static int sum1(int[] a) { return sumaux(a, 0, a.length-1); private static int sum1aux(int[] a, int from, int to) { if (from > to) { return 0; return a[from] + sum1aux(a, from+1, to); public static int sum2(int[] a) { return sum2rec(a, 0, a.length-1, 0); private static int sum2rec(int[] a, int from, int to, int res) { if (from > to) { return res; return sum2rec(a, from + 1, to, res + a[from]); See ArrayRec.java Reversing an array Write a recursive method reversearray that accepts an array and reverses the elements in place public static void reversearray(int[] a) { reversearrayaux(a, 0, a.length-1); // Reverses the element in a from index i to index j public static void reversearrayaux(int[] a, int i, int j) { if (i < j) { swap(a, i, j); reversearrayaux(a, i+1, j-1); Palindrome Write a recursive method ispalindrome that accepts a string and returns true if it reads the same forwards as backwards ispalindrome("madam") true ispalindrome("racecar") true ispalindrome("step on no pets ) true ispalindrome("java") false ispalindrome("rotater") false

6 ispalindrome // Returns true if the given string reads the same // forwards as backwards. // Trivially true for empty or 1-letter strings. public static boolean ispalindrome(string s) { if (s.length() < 2) { return true; char first = s.charat(0); char last = s.charat(s.length() - 1); if (first!= last) { return false; String rest= s.substring(1, s.length() - 1); return ispalindrome(rest); 21 Reversing an array (repeated) Write a recursive method reversearray that accepts an array and reverses the elements in place public static void reversearray(int[] a) { reversearrayaux(a, 0, a.length-1); // Reverses the element in a from index i to index j public static void reversearrayaux(int[] a, int i, int j) { if (i < j) { swap(a, i, j); reversearrayaux(a, i+1, j-1); 22 Tail recursion Recursive tracing Tail recursion occurs when a linearly recursive method makes its recursive call as its last step Such methods can easily be converted to non-recursive methods public static void reversearray2(int[] a) { reversearray2aux(a, 0, a.length-1); // Reverses the element in a from index i to index j public static void reversearray2aux(int[] a, int i, int j) { while (i < j) { swap(a, i, j); i++; j--; 23 Consider the following recursive method: public static int mystery(int n) { if (n < 10) { return n; int a = n / 10; int b = n % 10; return mystery(a + b); What is the result of the following call? mystery(648) 24 6

7 A recursive trace mystery(648): int a = 648 / 10; // 64 int b = 648 % 10; // 8 return mystery(a + b); // mystery(72) mystery(72): int a = 72 / 10; // 7 int b = 72 % 10; // 2 return mystery(a + b); // mystery(9) mystery(9): return 9; Recursive tracing 2 (next) Consider the following recursive method: public static int mystery2(int n) { if (n < 10) { return (10 * n) + n; int a = mystery2(n / 10); int b = mystery2(n % 10); return (100 * a) + b; Each box represents a stack frame! 25 What is the result of the following call? mystery2(348) 26 A recursive trace 2 printbinary mystery(348) int a = mystery(34); int a = mystery(3); return (10 * 3) + 3; // 33 int b = mystery(4); return (10 * 4) + 4; // 44 return (100 * 33) + 44; // 3344 Write a recursive method printbinary that accepts an integer and prints that number's representation in binary (base 2) printbinary(7) prints 111 printbinary(12) prints 1100 printbinary(43) prints int b = mystery(8); return (10 * 8) + 8; // 88 place value return (100 * 3344) + 88; // What is this method really doing? Write the method recursively and without using any loops

8 printbinary analysis printbinary Recursion is about solving a small piece of a large problem. Case analysis: What is/are easy numbers to print in binary? Can we express a larger number in terms of a smaller number(s)? Suppose we are examining some arbitrary integer n If n's binary representation is (n / 2)'s binary representation is (n % 2)'s binary representation is 1 // Prints a given integer's binary representation. // Precondition: n >= 0 public static void printbinary(int n) { if (n < 2) { // base case; same as base 10 System.out.print(n); // recursive case; break number apart printbinary(n / 2); printbinary(n % 2); // BTW, rewrite it using a loop for comparison Binary recursion Binary recursion occurs whenever there are two recursive calls for each non-base case Example: Fibonacci function in Fact.java public static int fib (int n) { if (n < 2) { return n; return fib(n - 1) + fib(n - 2); Multiple recursion Makes potentially many recursive calls Examples: Analyzing disk space usage of a file system in Section of the text Summation puzzles in Section of the text Also see recurse1 and recurse2 in Recursion.java We will use binary recursion when we study quick sort, merge sort, binary trees, etc

9 More examples See BinSearch.java from our Lecture 5 See Tower.java Hanoi1.jpg, Hanoi2.jpg, Hanoi3.jpg, Hanoi4.jpg Or Recursion/TowerofHanoi.html Or Analyzing recursive functions for runtime complexity Revisiting recursive factorial public static int fact(int n) { if (n == 1) { return 1; return n * fact(n - 1); Running time analysis of recursive functions Our usual counting technique is not applicable here because of the recursive call(s). Instead, we will use a recurrence relation, still using the simple model of computation in two steps: 1. Set up a recurrence relation 2. Solve the relation

10 Factorial Binary search public static int fact(int n) { if (n == 1) { return 1; return n * fact(n - 1); Recurrence relation: T(n) = T(n-1) + c Will solve it in class 37 public static int bsearch(int item, int[] a, int low, int high) { if (low > high) { return -1; int mid = (low + high) / 2; if (item < a[mid]) { return bsearch(item, a, low, mid - 1); else if (item > a[mid]) { return bsearch(item, a, mid + 1, high); return mid; Recurrence relation: T(n) = c + T(n/2) Will solve it in class 38 Tower of Hanoi public static void hanoi(int n, String init, String end, String temp) { if (n >= 1) { hanoi(n-1,,, ); System.out.println("move " + init + " to " + end); hanoi(n-1,,, ); Wait! Where is the base case in this function? Add one explicitly Recurrence relation: T(n) = 2T(n-1) + 1 Will solve it in class 39 10

CSE 143 Lecture 11. Decimal Numbers

CSE 143 Lecture 11. Decimal Numbers CSE 143 Lecture 11 Recursive Programming slides created by Marty Stepp http://www.cs.washington.edu/143/ Decimal Numbers A visual review of decimal numbers: We get 348 by adding powers of 10 348 = 300