fundamentals of computer science lecture 14: recursion instructor: evan korth new york university
TRANSCRIPT
![Page 1: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/1.jpg)
Fundamentals of Computer Science
Lecture 14: RecursionInstructor: Evan KorthNew York University
![Page 2: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/2.jpg)
Road Map
• Introduction to Recursion• Recursion Example #1: World’s Simplest
Recursion Program• Visualizing Recursion
– Using Stacks
• Recursion Example #2 • Computing Factorials
– Iterative Approach
• Computing Factorials– Recursive Approach
• Reading, Chapter 4, 4.10
![Page 3: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/3.jpg)
Introduction to Recursion
![Page 4: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/4.jpg)
Introduction to Recursion
• So far, we have seen methods that call other functions.– For example, the main() method calls the square()
function.
• Recursive Method:– A recursive method is a method that calls itself.
main()
square()
compute()
![Page 5: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/5.jpg)
Why use Recursive Methods?
• In computer science, some problems are more easily solved by using recursive functions.
• If you go on to take a computer science algorithms course, you will see lots of examples of this.
• For example:– Traversing through a directory or file system.
– Traversing through a tree of search results.
• For today, we will focus on the basic structure of using recursive methods.
![Page 6: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/6.jpg)
World’s Simplest Recursion Program
![Page 7: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/7.jpg)
World’s Simplest Recursion Program
public class Recursion{
public static void main (String args[]) {
count(0);System.out.println();
}
public static void count (int index) {
System.out.print(index);if (index < 2)
count(index+1);}
}
This program simply counts from 0-2:
012
This is where the recursion occurs.
You can see that the count() function
calls itself.
![Page 8: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/8.jpg)
Visualizing Recursion
• To understand how recursion works, it helps to visualize what’s going on.
• To help visualize, we will use a common concept called the Stack.
• A stack basically operates like a container of trays in a cafeteria. It has only two operations:– Push: you can push something onto the stack.
– Pop: you can pop something off the top of the stack.
• Let’s see an example stack in action.
![Page 9: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/9.jpg)
Stacks
Time: 0
Empty Stack
Time 1:
Push “2”
2
Time 2:
Push “8”
2
8
Time 3:
Pop: Gets 8
2
The diagram below shows a stack over time.
We perform two pushes and one pop.
Time 4:
Pop: Gets 2
![Page 10: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/10.jpg)
Stacks and Methods
• When you run a program, the computer creates a stack for you.
• Each time you invoke a method, the method is placed on top of the stack.
• When the method returns or exits, the method is popped off the stack.
• The diagram on the next page shows a sample stack for a simple Java program.
![Page 11: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/11.jpg)
Stacks and Methods
Time: 0
Empty Stack
Time 1:
Push: main()
main()
Time 2:
Push: square()
main()
square()
Time 3:
Pop: square()
returns a value.
method exits.
main()
Time 4:
Pop: main()
returns a value.
method exits.
![Page 12: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/12.jpg)
Stacks and Recursion
• Each time a method is called, you push the method on the stack.
• Each time the method returns or exits, you pop the method off the stack.
• If a method calls itself recursively, you just push another copy of the method onto the stack.
• We therefore have a simple way to visualize how recursion really works.
![Page 13: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/13.jpg)
Back to the Simple Recursion Program
• Here’s the code again. Now, that we understand stacks, we can visualize the recursion.
public class Recursion1V0{
public static void main (String args[]) {
count(0);System.out.println();
}
public static void count (int index) {
System.out.print(index);if (index < 2)
count(index+1);}
}
![Page 14: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/14.jpg)
Stacks and Recursion in Action
Time: 0
Empty Stack
Time 1:
Push: main()
main()
Time 2:
Push: count(0)
main()
count(0)
Time 3:
Push: count(1)
Inside count(0):print (index); 0if (index < 2) count(index+1);
Inside count(1):print (index); 1if (index < 2) count(index+1);
main()
count(0)
count(1)
Time 4:
Push: count(2)
main()
count(0)
count(1)
Inside count(2):print (index); 2 if (index < 2) count(index+1);This condition now fails!
Hence, recursion stops, and we proceed to pop all functions off the stack.
count(2)
Times 5-8:
Pop everything
…
![Page 15: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/15.jpg)
Recursion, Variation 1
What will the following program do?
public class Recursion1V1{
public static void main (String args[]) {
count(3);System.out.println();
}
public static void count (int index) {
System.out.print(index);if (index < 2)
count(index+1);}
}
![Page 16: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/16.jpg)
Recursion, Variation 2
What will the following program do?
public class Recursion1V2{
public static void main (String args[]) {
count(0);System.out.println();
}
public static void count (int index) {
if (index < 2) count(index+1);
System.out.print(index);}
}
Note that the print statement
has been moved to the end
of the method.
![Page 17: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/17.jpg)
Computing Factorials
![Page 18: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/18.jpg)
Factorials
• Computing factorials are a classic problem for examining recursion.
• A factorial is defined as follows:n! = n * (n-1) * (n-2) …. * 1;
• For example:1! = 1 (Base Case)
2! = 2 * 1 = 2
3! = 3 * 2 * 1 = 6
4! = 4 * 3 * 2 * 1 = 24
5! = 5 * 4 * 3 * 2 * 1 = 120
![Page 19: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/19.jpg)
Iterative Approachimport javax.swing.JOptionPane;
public class FindFactorialIterative{
public static void main (String args[]) {
int answer, n;String nAsString = JOptionPane.showInputDialog("Enter a number: ");n = Integer.parseInt (nAsString);answer = findFactorial (n);System.out.println ("Answer: " + answer);System.exit(0);
}
public static int findFactorial (int n) {
int i, factorial = n;for (i = n - 1; i >= 1; i--)
factorial = factorial * i;return factorial;
}}
This is an iterative solution to finding a factorial.
It’s iterative because we have a simple for loop.
Note that the for loop goes from n-1 to 1.
![Page 20: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/20.jpg)
Factorials
• Computing factorials are a classic problem for examining recursion.
• A factorial is defined as follows:n! = n * (n-1) * (n-2) …. * 1;
• For example:1! = 1 (Base Case)
2! = 2 * 1 = 2
3! = 3 * 2 * 1 = 6
4! = 4 * 3 * 2 * 1 = 24
5! = 5 * 4 * 3 * 2 * 1 = 120
If you study this table closely, you
will start to see a pattern.
![Page 21: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/21.jpg)
Seeing the Pattern
• Seeing the pattern in the factorial example is difficult at first.
• But, once you see the pattern, you can apply this pattern to create a recursive solution to the problem.
• Divide a problem up into:– What it can do (usually a base case)
– What it cannot do• What it cannot do resembles original problem
• The function launches a new copy of itself (recursion step) to solve what it cannot do.
![Page 22: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/22.jpg)
Factorials
• Computing factorials are a classic problem for examining recursion.
• A factorial is defined as follows:n! = n * (n-1) * (n-2) …. * 1;
• For example:1! = 1 (Base Case)
2! = 2 * 1 = 2
3! = 3 * 2 * 1 = 6
4! = 4 * 3 * 2 * 1 = 24
5! = 5 * 4 * 3 * 2 * 1 = 120
If you study this table closely, you
will start to see a pattern.
The pattern is as follows:
You can compute the factorial of
any number (n) by taking n and
multiplying it by the factorial of (n-1).
For example:
5! = 5 * 4!
(which translates to 5! = 5 * 24 = 120)
![Page 23: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/23.jpg)
Recursive Solution
public class FindFactorialRecursive{
public static void main (String args[]) {
for (int i = 1; i < 10; i++)System.out.println ( i + "! = " + findFactorial(i));
}
public static int findFactorial (int number) {
if ( (number == 1) || (number == 0) )return 1;
elsereturn (number * findFactorial (number-1));
}}
Base Case.
![Page 24: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/24.jpg)
Finding the factorial of 3
Time 2:
Push: fact(3)
main()
fact(3)
Time 3:
Push: fact(2)
Inside findFactorial(3):
if (number <= 1) return 1;
else return (3 * factorial (2));
main()
fact(3)
fact(2)
Time 4:
Push: fact(1)
Inside findFactorial(2):
if (number <= 1) return 1;
else return (2 * factorial (1));
main()
fact(3)
fact(2)
fact(1)
Inside findFactorial(1):
if (number <= 1) return 1;
else return (1 * factorial (0));
Time 5:
Pop: fact(1)
returns 1.
main()
fact(3)
fact(2)1
Time 6:
Pop: fact(2)
returns 2.
main()
fact(3)2
Time 7:
Pop: fact(3)
returns 6.
main()6
![Page 25: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/25.jpg)
2003 Prentice Hall, Inc. All rights reserved.
25
Example Using Recursion: The Fibonacci Series
• Fibonacci series– Each number in the series is sum of two previous numbers
• e.g., 0, 1, 1, 2, 3, 5, 8, 13, 21…
fibonacci(0) = 0 fibonacci(1) = 1fibonacci(n) = fibonacci(n - 1) + fibonacci( n – 2 )
• fibonacci(0) and fibonacci(1) are base cases
– Golden ratio (golden mean)
![Page 26: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/26.jpg)
2003 Prentice Hall, Inc. All rights reserved.
26
import javax.swing.JOptionPane;
public class FibonacciTest {
public static void main (String args[]){
long number, fibonacciValue;String numberAsString;numberAsString = JOptionPane.showInputDialog("What Fib value do you
want?");number = Long.parseLong( numberAsString );
fibonacciValue = fibonacci( number );
System.out.println (fibonacciValue);System.exit (0);
}
// recursive declaration of method fibonacci public static long fibonacci( long n ) {
if ( n == 0 || n == 1 ) return n;
else return fibonacci( n - 1 ) + fibonacci( n - 2 );
} // end method fibonacci} // end class FibonacciTest
![Page 27: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/27.jpg)
2003 Prentice Hall, Inc. All rights reserved.
27
Recursion vs. Iteration
• Iteration– Uses repetition structures (for, while or do…while)
– Repetition through explicitly use of repetition structure
– Terminates when loop-continuation condition fails
– Controls repetition by using a counter
• Recursion– Uses selection structures (if, if…else or switch)
– Repetition through repeated method calls
– Terminates when base case is satisfied
– Controls repetition by dividing problem into simpler one
![Page 28: Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University](https://reader030.vdocuments.net/reader030/viewer/2022032703/56649d1a5503460f949ef2eb/html5/thumbnails/28.jpg)
2003 Prentice Hall, Inc. All rights reserved.
28
Recursion vs. Iteration (cont.)
• Recursion– More overhead than iteration
– More memory intensive than iteration
– Can also be solved iteratively
– Often can be implemented with only a few lines of code