Survey

* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project

Document related concepts

Java (programming language) wikipedia , lookup

C Sharp syntax wikipedia , lookup

Scala (programming language) wikipedia , lookup

ALGOL 68 wikipedia , lookup

Join-pattern wikipedia , lookup

Functional programming wikipedia , lookup

Java performance wikipedia , lookup

Quicksort wikipedia , lookup

C syntax wikipedia , lookup

Subroutine wikipedia , lookup

C Sharp (programming language) wikipedia , lookup

Tail call wikipedia , lookup

Algorithm characterizations wikipedia , lookup

Recursion (computer science) wikipedia , lookup

Corecursion wikipedia , lookup

Transcript
```Recursion
 Recursive definitions
 Recursive methods
 Run-time stack & activation records
1
 Recursion is a math and programming tool
 Technically, not necessary
 Wasn’t available in early programming languages
 Some things are very easy to do with it, but difficult to do without it
 Frequently results in very short programs/algorithms
 Somewhat difficult to understand at first
 Often times less efficient than non-recursive counterparts
 Presents new opportunities for errors and misunderstanding
 Tempting to use, even when not necessary
 Recommendation – use with caution, and only if helpful
2
Recursive Definitions
 Factorial – Non-recursive Definition:
N! = N * (N-1) * (N-2) * … * 2 * 1
*Note that a corresponding Java program is easy to write
public static int fact(int n)
:
3
Recursive Definitions
 Factorial - Recursive Definition:
N! =
{
1
if N=1
Basis Case
N * (N-1)!
if N>=2
Recursive Case
Why is it called recursive?
Why do we need a basis case?
Note that the “recursive reference” is always on a smaller value.
4
Recursive Definitions
 Fibonacci - Non-Recursive Definition:
0 1 1 2 3 5 8 13 21 34 …
*Note that a corresponding Java program is easy to write…or is it?
public static int fib(int n)
:
5
Recursive Definitions
 Fibonacci - Recursive Definition:
fib(N) =
{
0
if N=1
Basis Case
1
if N=2
Basis Case
fib(N-1) + fib(N-2)
if N>=3
Recursive Case
Note there are two basis cases and two recursive references.
6
Recursive Java Programs
 Printing N Blank Lines – Non-Recursive:
public static void NBlankLines(int n) {
for (int i=1; i<=n; i++)
System.out.println();
}
7
Recursive Java Programs
 Printing N Blank Lines – Recursive:
// NBlankLines outputs n blank lines, for n>=0
public static void NBlankLines(int n) {
if (n <= 0)
Basis Case
return;
else {
System.out.println();
NBlankLines(n-1);
Recursive Case
}
}
*Don’t ever write it this way; this is a simple, first example of recursion.
8
Recursive Java Programs
 Another Equivalent Version (slightly restructured):
// NBlankLines outputs n blank lines, for n>=0
public static void NBlankLines(int n) {
if (n > 0) {
System.out.println();
NBlankLines(n-1);
}
}
9
Recursive Java Programs
public static void main(String[] args) {
:
NBlankLines(3);
:
}
public static void NBlankLines(int n) {
n=3
public static void NBlankLines(int n) {
if (n > 0) {
n=1
if (n > 0) {
System.out.println();
System.out.println();
NBlankLines(n-1);
NBlankLines(n-1);
}
}
}
}
public static void NBlankLines(int n) {
n=2
public static void NBlankLines(int n) {
if (n > 0) {
if (n > 0) {
System.out.println();
System.out.println();
NBlankLines(n-1);
NBlankLines(n-1);
}
}
}
}
10
n=0
Recursive Java Programs
 A Similar Method:
public static void TwoNBlankLines(int n) {
if (n > 0) {
System.out.println();
TwoNBlankLines(n-1);
System.out.println();
}
}
11
Recursive Java Programs
public static void main(String[] args) {
:
TwoNBlankLines(2);
:
}
public static void TwoNBlankLines(int n) {
n=2
public static void TwoNBlankLines(int n) {
if (n > 0) {
if (n > 0) {
System.out.println();
System.out.println();
TwoNBlankLines(n-1);
TwoNBlankLines(n-1);
System.out.println();
System.out.println();
}
}
}
}
public static void TwoNBlankLines(int n) {
n=1
if (n > 0) {
System.out.println();
TwoNBlankLines(n-1);
System.out.println();
}
}
12
n=0
 Are the Following Methods the Same or Different?
public static void TwoNBlankLines(int n) {
if (n > 0) {
System.out.println();
System.out.println();
TwoNBlankLines(n-1);
}
}
public static void TwoNBlankLines(int n) {
if (n > 0) {
TwoNBlankLines(n-1);
System.out.println();
System.out.println();
}
}
13
 Recursive Factorial Definition:
N! =
{
1
N * (N-1)!
if N=1 Basis Case
if N>=2 Recursive Case
 Recursive Factorial Program:
public static int fact (int n) {
if (n==1)
return 1;
else {
int x;
x = fact (n-1);
Basis Case
Recursive Case
return x*n;
}
}
14
 Another Version:
public static int fact (int n) {
if (n==1)
return 1;
Basis Case
return n*fact (n-1);
Recursive Case
else
}
15
 Recursive Fibonacci Definition:
fib(N) =
{
0
if N=1
1
if N=2
fib(N-1) + fib(N-2)if N>=3
Basis Case
Basis Case
Recursive Case
 Recursive Fibonacci Program:
public static int fib (int n) {
if (n==1)
return 0;
else if (n==2)
return 1;
else {
int x,y;
x = fib (n-1);
y = fib (n-2);
return x+y;
}
}
Basis Case
Basis Case
Recursive Case
16
 Another Version:
public static int fib (int n) {
if (n==1)
return 0;
else if (n==2)
return 1;
else
return fib(n-1) + fib(n-2);
}
17
Recursion & the Run-time Stack
 How does recursion related to stack frames and the run time
stack?
 Note that stack frames are sometimes called allocation records or activation
records
 Why might a recursive program be less efficient than nonrecursive counterpart?
 Why is the recursive fibonnaci function especially inefficient?
18
```
Related documents