Important Notes Remaining Schedule: recall the 2 bad weather days (Jan 8th, Jan 17th) we will need to make up. In providing the 2 weeks needed for the big project (project 3 worth 12%) and lectures covering Ch 19 and Ch 20, I will do the following: You will have 2 weeks (or 4 class meetings) to work on Project 3 as promised (weeks of 4/9 and 4/16) The project will be rolled out on 4/9 Also in providing the remaining lectures, an online for Ch 19 will be posted on 4/11 and an online for Ch 20 will be posted on 4/18 China Trip/Final Exam Issue: Will be leaving May 1st for China for 13 days. Will set up exam with lockdown browser with cam – closed book – must pre-determine a suitable machine (labs ?) – practice exam will be setup – all must try it prior to the actual exam. I will determine and submit your final grade while abroad. Dr. Clincy - Lecture

Chapter 18 Recursion What is Recursion ?: When a thing, process or algorithm is defined in terms of itself or of its type A recursive method is one that can invoke itself directly or indirectly in solving some problem. Difference between “recursion” and “iteration” Recursion: function calling itself Iteration: controlled loop implementing function What are the benefits of recursion ?: It enables the programmer to develop a natural, straightforward and simple solution to an otherwise difficult problem Dr. Clincy - Lecture

Example - Recursive Methods Two well known use of recursion: N-factorial (n!) Algorithm Fibonacci-series Problem N-factorial: mathematical expression for the number of ways n items of a data set can be arranged – permutations. Fibonacci-series: a series of numbers where every number after the first two numbers is the sum There are many different scientific and mathematical processes and phenomena that can be modeled using a Fibonacci series Dr. Clincy - Lecture

2! 3! N-Factorial (n!) Computing Factorial N-factorial: mathematical expression for the number of ways n items of a data set can be arranged – permutations. 2! 3! Computing Factorial n! = n * (n-1)! 0! = 1 factorial(0) = 1; factorial(n) = n*factorial(n-1); Needed to eventually “stop” the recursion Why is 0!=1 ? Because there is one way to arrange a data set of “nothing”. Also, 1!=1 Dr. Clincy - Lecture

Computing Factorial Import needed User enter integer Factorial method call Factorial method If 0, n!=1 n! = n x (n-1)! (n-1)! Is needed to eventually stop the recursion Function calling itself Enter a nonnegative integer: 4 [ENTER] Factorial of 4 is 24 Factorial of 10 is 3628800 Dr. Clincy - Lecture

Computing Factorial factorial(4) factorial(0) = 1; animation Computing Factorial factorial(0) = 1; factorial(n) = n*factorial(n-1); factorial(4) Dr. Clincy - Lecture

Example - Computing Factorial animation Example - Computing Factorial factorial(0) = 1; factorial(n) = n*factorial(n-1); factorial(4) = 4 * factorial(3) Dr. Clincy - Lecture

Computing Factorial factorial(4) = 4 * factorial(3) animation Computing Factorial factorial(0) = 1; factorial(n) = n*factorial(n-1); factorial(4) = 4 * factorial(3) = 4 * 3 * factorial(2) Dr. Clincy - Lecture

Computing Factorial factorial(4) = 4 * factorial(3) animation Computing Factorial factorial(0) = 1; factorial(n) = n*factorial(n-1); factorial(4) = 4 * factorial(3) = 4 * 3 * factorial(2) = 4 * 3 * (2 * factorial(1)) Dr. Clincy - Lecture

Computing Factorial factorial(4) = 4 * factorial(3) animation Computing Factorial factorial(0) = 1; factorial(n) = n*factorial(n-1); factorial(4) = 4 * factorial(3) = 4 * 3 * factorial(2) = 4 * 3 * (2 * factorial(1)) = 4 * 3 * ( 2 * (1 * factorial(0))) Dr. Clincy - Lecture

Computing Factorial factorial(4) = 4 * factorial(3) animation Computing Factorial factorial(0) = 1; factorial(n) = n*factorial(n-1); factorial(4) = 4 * factorial(3) = 4 * 3 * factorial(2) = 4 * 3 * (2 * factorial(1)) = 4 * 3 * ( 2 * (1 * factorial(0))) = 4 * 3 * ( 2 * ( 1 * 1))) Dr. Clincy - Lecture

Computing Factorial factorial(4) = 4 * factorial(3) animation Computing Factorial factorial(0) = 1; factorial(n) = n*factorial(n-1); factorial(4) = 4 * factorial(3) = 4 * 3 * factorial(2) = 4 * 3 * (2 * factorial(1)) = 4 * 3 * ( 2 * (1 * factorial(0))) = 4 * 3 * ( 2 * ( 1 * 1))) = 4 * 3 * ( 2 * 1) Dr. Clincy - Lecture

Computing Factorial factorial(4) = 4 * factorial(3) animation Computing Factorial factorial(0) = 1; factorial(n) = n*factorial(n-1); factorial(4) = 4 * factorial(3) = 4 * 3 * factorial(2) = 4 * 3 * (2 * factorial(1)) = 4 * 3 * ( 2 * (1 * factorial(0))) = 4 * 3 * ( 2 * ( 1 * 1))) = 4 * 3 * ( 2 * 1) = 4 * 3 * 2 Dr. Clincy - Lecture

Computing Factorial factorial(4) = 4 * factorial(3) animation Computing Factorial factorial(0) = 1; factorial(n) = n*factorial(n-1); factorial(4) = 4 * factorial(3) = 4 * (3 * factorial(2)) = 4 * (3 * (2 * factorial(1))) = 4 * (3 * ( 2 * (1 * factorial(0)))) = 4 * (3 * ( 2 * ( 1 * 1)))) = 4 * (3 * ( 2 * 1)) = 4 * (3 * 2) = 4 * (6) Dr. Clincy - Lecture

Computing Factorial factorial(4) = 4 * factorial(3) animation Computing Factorial factorial(0) = 1; factorial(n) = n*factorial(n-1); factorial(4) = 4 * factorial(3) = 4 * (3 * factorial(2)) = 4 * (3 * (2 * factorial(1))) = 4 * (3 * ( 2 * (1 * factorial(0)))) = 4 * (3 * ( 2 * ( 1 * 1)))) = 4 * (3 * ( 2 * 1)) = 4 * (3 * 2) = 4 * (6) = 24 Dr. Clincy - Lecture

Trace Recursive factorial animation Trace Recursive factorial Executes factorial(4) Dr. Clincy - Lecture

Trace Recursive factorial animation Trace Recursive factorial Executes factorial(3) Dr. Clincy - Lecture

Trace Recursive factorial animation Trace Recursive factorial Executes factorial(2) Dr. Clincy - Lecture

Trace Recursive factorial animation Trace Recursive factorial Executes factorial(1) Dr. Clincy - Lecture

Trace Recursive factorial animation Trace Recursive factorial Executes factorial(0) Dr. Clincy - Lecture

Trace Recursive factorial animation Trace Recursive factorial returns 1 Dr. Clincy - Lecture

Trace Recursive factorial animation Trace Recursive factorial returns factorial(0) Dr. Clincy - Lecture

Trace Recursive factorial animation Trace Recursive factorial returns factorial(1) Dr. Clincy - Lecture

Trace Recursive factorial animation Trace Recursive factorial returns factorial(2) Dr. Clincy - Lecture

Trace Recursive factorial animation Trace Recursive factorial returns factorial(3) Dr. Clincy - Lecture

Trace Recursive factorial animation Trace Recursive factorial returns factorial(4) Dr. Clincy - Lecture

factorial(4) Stack Trace Dr. Clincy - Lecture

Example - Fibonacci Numbers Fibonacci-series: a series of numbers where every number after the first two numbers is the sum Fibonacci series: 0 1 1 2 3 5 8 13 21 34 55 89… indices: 0 1 2 3 4 5 6 7 8 9 10 11 fib(0) = 0; fib(1) = 1; fib(index) = fib(index -1) + fib(index -2); index >=2 fib(3) = fib(2) + fib(1) = (fib(1) + fib(0)) + fib(1) = (1 + 0) +fib(1) = 1 + fib(1) = 1 + 1 = 2 Dr. Clincy - Lecture

Fibonacci Numbers fib(0) = 0; fib(1) = 1; fib(index) = fib(index -1) + fib(index -2); index >=2 Allow user to enter desired index Initial method call to determine f-number at index Fibonacci method If index 0, f-number is 0 If index 1, f-number is 1 Recursion: method calling itself twice – implementing from left to right Enter an index for Fibonacci number: 1 [ENTER] The Fibonacci number at index 1 is 1 Enter an index for Fibonacci number: 6 [ENTER] The Fibonacci number at index 6 is 8 Enter an index for Fibonacci number: 7 [ENTER] The Fibonacci number at index 7 is 13 Dr. Clincy - Lecture

Example - Fibonnaci Number for Index =4 Left then Right Dr. Clincy - Lecture

Characteristics of Recursion All recursive methods have the following characteristics: One or more base cases (the simplest case) are used to stop recursion. Every recursive call reduces the original problem, bringing it increasingly closer to a base case until it becomes that case. In general, to solve a problem using recursion, you break it into subproblems. If a subproblem resembles the original problem, you can apply the same approach to solve the subproblem recursively. This subproblem is almost the same as the original problem in nature with a smaller size. Dr. Clincy - Lecture

Recursion Disadvantage Recursion Advantage Recursion is good for solving the problems that are inherently recursive. Recursion Disadvantage Recursion bears substantial overhead. Each time the program calls a method, the system must assign space for all of the method’s local variables and parameters. This can consume considerable memory and requires extra time to manage the additional space. Dr. Clincy - Lecture

Your chapter 18 has other examples of recursive methods implemented Cover Lab 14 Dr. Clincy - Lecture