1 / 84

Recursion

Recursion. Aaron Tan. http://www.comp.nus.edu.sg/~tantc/cs1101.html. Recursion. Recursion. +. What is Recursion? (1/2). To perform a task T by performing some similar smaller task(s) T’ . Example: Formula for factorial: n ! = n * ( n -1) * ( n -2) * … * 2 * 1 for n > 0 0! = 1

daniel_millan
Download Presentation

Recursion

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Recursion Aaron Tan http://www.comp.nus.edu.sg/~tantc/cs1101.html

  2. Recursion Recursion +

  3. What is Recursion? (1/2) • To perform a task T by performing some similar smaller task(s) T’. • Example: • Formula for factorial: n! = n * (n-1) * (n-2) * … * 2 * 1 for n > 0 0! = 1 • Recursive formula for factorial: n! = n * (n–1)! for n>0 0! = 1 (Examples: 3! = 6; 4! = 24; 7! = 5040)

  4. What is Recursion? (2/2) • The idea behind recursion is similar to PMI (Principle of Mathematical Induction). • Example: Prove the recursive formula for factorial. • Basis: 0! = 1 • Induction hypothesis: Assume that the recursive formula is true for x > 0. • Inductive step: (x + 1)! = (x + 1) * x * (x – 1) * … * 1 = (x + 1) * x!

  5. Recursive Definitions • A definition that defines something in terms of itself is called a recursive definition. • The descendants of a person are the person’s children and all of the descendants of the person’s children. • A list of numbers is • a number or • a number followed by a comma and a list of numbers. • A recursive algorithm is an algorithm that invokes itself to solve smaller or simpler instances of a problem instances. • The factorial of a number n is: n times the factorial of n-1.

  6. How to Multiply 6 by 3? (1/5) • Assume that we know only addition but not multiplication, except for the simplest case of x * 1 = x. • To employ recursion, we solve our problem by solving a smaller (but similar) problem, and then use the solution of this smaller problem to derive the solution of the original problem.

  7. How to Multiply 6 by 3? (2/5) • To solve ‘multiply 6 by 3’: 1. Solve smaller problem: Multiply 6 by 2. 2. Connect the solution of the smaller problem with the solution of the original problem:Add 6 to the result of (1). • Apply the same technique to solve ‘multiply 6 by 2’: 1.1. Solve smaller problem: Multiply 6 by 1. 1.2. Connect the solution of the smaller problem with the solution of the original problem:Add 6 to the result of (1.1).

  8. How to Multiply 6 by 3? (3/5) • To solve ‘multiply 6 by 1’: Do not need to solve smaller problem as the problem can be solved directly. Answer: 6 * 1 = 6. • We then reconstruct the solution • ‘Multiply 6 by 1’ is 6. • ‘Multiply 6 by 2’ is 6 + the solution of ‘multiply 6 by 1’, or 12. • ‘Multiply 6 by 3’ is 6 + the solution of ‘multiply 6 by 2’, or 18.

  9. How to Multiply 6 by 3? (4/5) // recursive method to compute // m * n, where n is positive public static int multiply (int m, int n) { int ans; if (n==1) ans = m; // simple case else ans = m + multiply(m, n-1); return ans; } or public static int multiply (int m, int n) { if (n==1) return m; else return m + multiply(m, n-1); }

  10. How to Multiply 6 by 3? (5/5) // iterative method to compute // m * n, where n is positive public static int multiply (int m, int n) { int ans = 0; for (int i = 1; i <= n; ++i) ans += m; return ans; } or public static int multiply (int m, int n) { int ans = 0; while (n-- > 0) ans += n; return ans; }

  11. If I could just get someone to count the s’s in this smaller string… … then the number of s’s is either that number or 1 more, depending on whether the first letter is an s. Count Occurrences of Character (1/4) • We want countChar('s', "Mississippi sassafras") to return the value of 8. • Recursive thinking goes... Mississippi sassafras

  12. Count Occurrences of Character (2/4) // count the number of occurrences // of character ch in string str. public static int countChar(char ch, String str) { int ans; if (str.length() == 0) // base case ans = 0; else if (str.charAt(0) == ch) ans = 1 + countChar(ch, str.substring(1)); else ans = countChar(ch, str.substring(1)); return ans; }

  13. Count Occurrences of Character (3/4) or public static int countChar(char ch, String str) { if (str.length() == 0) // base case return 0; else if (str.charAt(0) == ch) return 1 + countChar(ch, str.substring(1)); else return countChar(ch, str.substring(1)); }

  14. Count Occurrences of Character (4/4) Compare with iterative version: public static int countChar(char ch, String str) { int ans = 0; for (int i = 0; i < str.length(); ++i) { if (str.charAt(i) == ch) ++ans; } return ans; }

  15. Ellipsis tells the reader to use intuition to recognise the pattern. Factorial: Definition • An imprecise definition • A precise definition

  16. Recursive Methods • A recursive method generally has two parts. • A termination part that stops the recursion. • This is called the base case (or anchor case). • The base case should have a simple or trivial solution. • One or more recursive calls. • This is called the recursive case. • The recursive case calls the same method but with simpler or smaller arguments. if ( base case satisfied ) { return value; } else { make simpler recursive call(s); }

  17. Base case. Recursive case deals with a simpler (smaller) version of the same task. factorial() (1/2) public static int factorial(n) { if (n == 0) return 1; else return n * factorial(n-1); }

  18. factorial() (2/2) public static int factorial(n) { if (n == 0) return 1; else return n * factorial(n-1); } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int number = scanner.nextInt(); int nfactorial = factorial(number); System.out.println(number + "! = " + nfactorial); }

  19. factorial() n = 3 return n * factorial(n-1); factorial() n = 2 return n * factorial(n-1); factorial() n = 1 return n * factorial(n-1); factorial() n = 0 return 1; Factorial: Recursive Invocation • A new activation record is created for every method invocation • Including recursive invocations main() int nfactorial = factorial(n);

  20. main() int nfactorial = factorial(n); factorial() n = 3 return n * factorial(n-1); factorial() n = 2 return n * factorial(n-1); factorial() n = 1 return n * factorial(n-1); factorial() n = 0 return 1; Factorial: Result Passing (1/12)

  21. main() int nfactorial = factorial(n); factorial() n = 3 return n * factorial(n-1); factorial() n = 2 return n * factorial(n-1); factorial() n = 1 return n * factorial(n-1); factorial() n = 0 return 1; Factorial: Result Passing (2/12)

  22. main() int nfactorial = factorial(n); factorial() n = 3 return n * factorial(n-1); factorial() n = 2 return n * factorial(n-1); factorial() n = 1 return n * 1; Factorial: Result Passing (3/12)

  23. main() int nfactorial = factorial(n); factorial() n = 3 return n * factorial(n-1); factorial() n = 2 return n * factorial(n-1); factorial() n = 1 return 1 * 1; Factorial: Result Passing (4/12)

  24. main() int nfactorial = factorial(n); factorial() n = 3 return n * factorial(n-1); factorial() n = 2 return n * factorial(n-1); factorial() n = 1 return 1 * 1; Factorial: Result Passing (5/12)

  25. main() int nfactorial = factorial(n); factorial() n = 3 return n * factorial(n-1); factorial() n = 2 return n * 1; Factorial: Result Passing (6/12)

  26. main() int nfactorial = factorial(n); factorial() n = 3 return n * factorial(n-1); factorial() n = 2 return 2 * 1; Factorial: Result Passing (7/12)

  27. main() int nfactorial = factorial(n); factorial() n = 3 return n * factorial(n-1); factorial() n = 2 return 2 * 1; Factorial: Result Passing (8/12)

  28. main() int nfactorial = factorial(n); factorial() n = 3 return n * 2; Factorial: Result Passing (9/12)

  29. main() int nfactorial = factorial(n); factorial() n = 3 return 3 * 2; Factorial: Result Passing (10/12)

  30. main() int nfactorial = factorial(n); factorial() n = 3 return 3 * 2; Factorial: Result Passing (11/12)

  31. main() int nfactorial = 6; Factorial: Result Passing (12/12)

  32. Infinite Recursion • A common programming error when using recursion is to not stop making recursive calls. • The program will continue to recurse until it runs out of memory. • Be sure that your recursive calls are made with simpler or smaller subproblems, and that your algorithm has a base case that terminates the recursion. • Avoid redundant base case: public static int factorial(n) { if (n == 0) return 1; else if (n == 1) return 1; else return n * factorial(n-1); }

  33. Computing Sum of Squares (1/5) • Given 2 positive integers m and n, where m ≤ n, compute: sumSquares(m, n) = m2 + (m+1)2 + … + n2 • Example: sumSquares(5, 10) = 52 + 62 + 72 + 82 + 92 + 102 = 355

  34. Computing Sum of Squares (2/5) • ‘Going-up’ recursion: public static int sumSquares (int m, int n) { if (m == n) return m * m; else return m*m + sumSquares(m+1, n); } • ‘Going-down’ recursion: public static int sumSquares (int m, int n) { if (m == n) return n * n; else return n*n + sumSquares(m, n-1); }

  35. Computing Sum of Squares (3/5) • ‘Combining two half-solutions’ recursion: public static int sumSquares (int m, int n) { if (m == n) return m * m; else { int middle = (m + n)/2; return sumSquares(m, middle) + sumSquares(middle+1, n); } }

  36. 355 sumSquares(5,10) 100 + 255 sumSquares(5,9) 81 + 174 sumSquares(5,8) 64 + 110 sumSquares(5,7) 49 + 61 sumSquares(5,6) 36 + 25 sumSquares(5,5) 25 Computing Sum of Squares (4/5) • Call trees for ‘going-up’ and ‘going-down’ versions. 355 sumSquares(5,10) 25 + 330 sumSquares(6,10) 36 + 294 sumSquares(7,10) 49 + 245 sumSquares(8,10) 64 + 181 sumSquares(9,10) 81 + 100 sumSquares(10,10) 100

  37. 355 sumSquares(5,10) 110 245 sumSquares(5,7) sumSquares(8,10) 61 49 145 100 sumSq(5,6) sumSq(7,7) sumSq(8,9) sumSq(10,10) 25 36 49 64 81 100 sumSq(5,5) sumSq(6,6) sumSq(8,8) sumSq(9,9) 25 36 64 81 Computing Sum of Squares (5/5) • Call tree for ‘combining two half-solutions’ version.

  38. Computing GCD (1/7) • Greatest common divisor (GCD) of two non-negative integers (not both zero). +

  39. Computing GCD (2/7) • Trace gcd(539, 84) public static intgcd(int m, int n) { if (n == 0) return m; else return gcd(n, m % n); } gcd(539, 84) gcd(84, 35) gcd(35, 14) gcd(14, 7) gcd(7, 0)

  40. Computing GCD (3/7) • Trace gcd(539, 84) public static intgcd(int m, int n) { if (n == 0) return m; else return gcd(n, m % n); } gcd(539, 84) gcd(84, 35) gcd(35, 14) gcd(14, 7) 7 gcd(7, 0)

  41. Computing GCD (4/7) • Trace gcd(539, 84) public static intgcd(int m, int n) { if (n == 0) return m; else return gcd(n, m % n); } gcd(539, 84) gcd(84, 35) gcd(35, 14) 7 gcd(14, 7)

  42. Computing GCD (5/7) • Trace gcd(539, 84) public static intgcd(int m, int n) { if (n == 0) return m; else return gcd(n, m % n); } gcd(539, 84) gcd(84, 35) 7 gcd(35, 14)

  43. Computing GCD (6/7) • Trace gcd(539, 84) public static intgcd(int m, int n) { if (n == 0) return m; else return gcd(n, m % n); } gcd(539, 84) 7 gcd(84, 35)

  44. Computing GCD (7/7) • Trace gcd(539, 84) public static intgcd(int m, int n) { if (n == 0) return m; else return gcd(n, m % n); } 7 gcd(539, 84)

  45. Fibonacci Numbers (1/5) • Developed by Leonardo Pisano in 1202. • Investigating how fast rabbits could breed under idealized circumstances. • Assumptions • A pair of male and female rabbits always breed and produce another pair of male and female rabbits. • A rabbit becomes sexually mature after one month, and that the gestation period is also one month. • Pisano wanted to know the answer to the question how many rabbits would there be after one year?

  46. Fibonacci Numbers (2/5) • The sequence generated is: 1, 1, 2, 3, 5, 8, 13, 21, 34, … • Some version starts with 0: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, … • The number of pairs for a month is the sum of the number of pairs in the two previous months.

  47. Fibonacci Numbers (3/5) • What is the equation for Fibonacci sequence? +

  48. Fibonacci Numbers (4/5) // Version 1: 0, 1, 1, 2, 3, 5, 8, 13, 21, ... public static int fibonacci (int n) { if (n <= 1) return n; else return fibonacci(n-1) + fibonacci(n-2); } // Version 2: 1, 1, 2, 3, 5, 8, 13, 21, 34, ... public static int fibonacci (int n) { if (n <= 2) return 1; else return fibonacci(n-1) + fibonacci(n-2); }

  49. 5 Fibonacci(5) 3 2 Fibonacci(4) Fibonacci(3) 2 1 1 1 Fibonacci(3) Fibonacci(2) Fibonacci(2) Fibonacci(1) 1 1 Fibonacci(2) Fibonacci(1) Fibonacci Numbers (5/5)

  50. Tracing Recursive Codes (1/2) • Beginners usually rely on tracing to understand the sequence of recursive calls and the passing back of results. • Tail recursion is one in which the recursive call is the last operation in the code. • Examples encountered that are tail-recursive: factorial, sum of squares (‘going-up’ and ‘going-down’ versions), GCD. • Examples that are not tail-recursive: sum of squares (‘combining two half-solutions’ version), Fibonacci sequence. • However, tracing a recursive code is tedious, especially for non-tail-recursive codes. The call tree could be huge (example: Fibonacci.)

More Related