Understanding Recursion
Introduction
 Recursion is a powerful programming technique that
provides elegant solutions to certain problems.
Introduction
 Recursion is a powerful programming technique that
provides elegant solutions to certain problems.
 Recursion is a programming technique in which a
method calls itself either directly, or indirectly through
another method.
A Mathematical Example Factorials
 Mathematical formulas often are expressed recursively.
A Mathematical Example Factorials
 Mathematical formulas often are expressed recursively.
 In the following example, we will look in depth at
factorials.
Definition of Factorial
Factorials - !
The symbol for factorial is “!” - the exclamation mark. The factorial of
a positive integer is the product of all nonnegative integers less than
or equal to that number.
Zero factorial is a special case and 0! = 1
From this definition, 5! is 120.
5! = 5 . 4 . 3 . 2 . 1 = 120
This formula often is defined recursively, for all nonnegative integers
as:
n! = n(n-1)! for n > 0; 0! = 1;
Any number factorial is that number times the factorial of one less
than that number.
A Closer Look
Now, let’s look at the expression,
n! = n * (n-1)! for n > 0; 0! = 1
You will notice that n! subtracts 1 from n, then
recomputes the factorial of n-1. This is the
recursion.
A Closer Look
Now, let’s look at the expression,
n! = n * (n-1)! for n > 0; 0! = 1
Also notice that the simplest case is 0! This is
called the base case.
Base Cases
Base cases are important. A recursive method
can solve only a base case.
Base Cases
Base cases are important. A recursive method
can solve only a base case.
If the method is called with a base case, it
returns a result. If the methods is called with
something other than the base case, the
recursive method will decide what part it can
accomplish, and then call itself to solve the rest
of the problem.
Converting to Code
n! = n · (n-1)! for n > 0;
0! = 1
To understand how to
program recursively, we will
convert the mathematical
definition of factorial into
code.
Converting to Code
n! = n · (n-1)! for n > 0;
0! = 1
public class FactorialExample {
To understand how to
program recursively, we will
convert the mathematical
definition of factorial into
code.
We’ll start by creating a class,
FactorialExample.
}
Converting to Code
n! = n · (n-1)! for n > 0;
0! = 1
public class FactorialExample {
For simplicity, we will add a
main method.
}
Converting to Code
n! = n · (n-1)! for n > 0;
0! = 1
public class FactorialExample {
For simplicity, we will add a
main method.
The main method will create
a FactorialExample
object.
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
}
}
Converting to Code
n! = n · (n-1)! for n > 0;
0! = 1
public class FactorialExample {
public long factorial(long number) {
We’ll add our recursive
method, factorial.
}
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
}
}
Converting to Code
n! = n · (n-1)! for n > 0;
0! = 1
public class FactorialExample {
public long factorial(long number) {
We now need to identify the
base case; that is, the case
the method factorial can
solve without calling itself.
}
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
}
}
Converting to Code
n! = n · (n-1)! for n > 0;
0! = 1
public class FactorialExample {
public long factorial(long number) {
In the formula above, we can
use 0! = 1 as the base case.
0! is the simplest case.
}
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
}
}
Converting to Code
n! = n · (n-1)! for n > 0;
0! = 1
public class FactorialExample {
public long factorial(long number) {
In the formula above, we can
use 0! = 1 as the base case.
0! is the simplest case.
if (number == 0)
return 1;
}
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
}
}
Converting to Code
n! = n · (n-1)! for n > 0;
0! = 1
public class FactorialExample {
public long factorial(long number) {
In the formula above, we can
use 0! = 1 as the base case.
0! is the simplest case.
However, 1! also equals 1.
We can take advantage of
this and change the code.
if (number == 0)
return 1;
}
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
}
}
Converting to Code
n! = n · (n-1)! for n > 0;
0! = 1
public class FactorialExample {
public long factorial(long number) {
In the formula above, we can
use 0! = 1 as the base case.
0! is the simplest case.
However, 1! also = 1. We
can take advantage of this
and change the code.
if (number <= 1)
return 1;
}
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
}
}
Converting to Code
n! = n · (n-1)! for n > 0;
0! = 1
public class FactorialExample {
public long factorial(long number) {
Now, we need to add
recursion.
We will look at the first part
of the formula,
n · (n-1)!
If number is greater than 1,
we need to compute
n · (n-1)!
if (number <= 1)
return 1;
}
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
}
}
Converting to Code
n! = n · (n-1)! for n > 0;
0! = 1
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
Now, we need to add
recursion.
We will look at the first part
of the formula,
n · (n-1)!
If number is greater than 1,
we need to compute
n · (n-1)!
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
}
}
Examining the Code
The best way to understand
recursion is to step through
the code.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
}
}
Examining the Code
The best way to understand
recursion is to step through
the code.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
We will use 5! as our test
case.
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
}
}
Examining the Code
The best way to understand
recursion is to step through
the code.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
We will use 5! as our test
case,
and modify main slightly.
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + “! = “ +
answer);
}
Stepping through the Code
The code starts by creating
a FactorialExample
object, fact.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
answer);
}
Stepping through the Code
The testNumber variable is
created and set to 5. The
answer variable is created.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The factorial method is
called.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The formal parameter
number is created.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
number
5
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The formal parameter
number is not less than or
equal to 1.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
number
5
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
This line is the recursive call.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
number
5
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
This line is the recursive call.
The method will return the
value of number (in this
case, 5), multiplied by . . .
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
number
5
answer = fact.factorial(testNumber);
return: 5 *
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
This line is the recursive call.
The method will return the
value of number (in this
case, 5), multiplied by . . .
The result of the method’s
recursive call to itself.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
number
5
answer = fact.factorial(testNumber);
return: 5 *
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The factorial method is
called, and another formal
parameter number is
created.
4
number
5
public long factorial(long number) {
if (number <= 1)
return 1;
This time the value of
number is the previous
formal parameter’s value
(number - 1) or 4.
number
public class FactorialExample {
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
return: 5 *
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The formal parameter
number is not less than or
equal to 1.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
number
4
number
5
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
return: 5 *
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
So, the method will return
the value of number (in this
case, 4), multiplied by . . .
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
number
4
return: 4 *
number
5
return: 5 *
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
So, the method will return
the value of number (in this
case, 4), multiplied by . . .
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
The result of the method’s
recursive call to itself.
return 1;
else
return number * factorial(number - 1);
}
number
4
return: 4 *
number
5
return: 5 *
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
Another formal parameter
number is created.
public class FactorialExample {
public long factorial(long number) {
This time the value of
number is the previous
formal parameter’s value
(number - 1) or 3.
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
number
3
number
4
return: 4 *
number
5
return: 5 *
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The method returns 3 * the
result of another recursive
call.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
number
3
return: 3 *
number
4
return: 4 *
number
5
return: 5 *
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The method returns 3 * the
result of another recursive
call, with a new formal
parameter.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
number
2
number
3
return: 3 *
number
4
return: 4 *
number
5
return: 5 *
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The method returns 2 * the
result of another recursive
call,
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
number
2
return: 2 *
}
number
3
return: 3 *
number
4
return: 4 *
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
number
5
return: 5 *
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
with a new formal
parameter.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
number
1
number
2
return: 2 *
}
number
3
return: 3 *
number
4
return: 4 *
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
number
5
return: 5 *
else
return number * factorial(number - 1);
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The method finally can solve
its base case.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
number
1
number
2
return: 2 *
}
number
3
return: 3 *
number
4
return: 4 *
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
number
5
return: 5 *
else
return number * factorial(number - 1);
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
number is equal to 1.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
number
1
number
2
return: 2 *
}
number
3
return: 3 *
number
4
return: 4 *
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
number
5
return: 5 *
else
return number * factorial(number - 1);
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The method returns 1.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
number
1
return: 1
number
2
return: 2 *
}
number
3
return: 3 *
number
4
return: 4 *
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
number
5
return: 5 *
else
return number * factorial(number - 1);
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
Control is returned to the
calling method.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
number
2
return: 2 *
number
3
return: 3 *
number
4
return: 4 *
number
5
return: 5 *
1
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The calling method now can
return a value, in this case
( 2 * 1 ) or 2.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
number
2
return: 2 *
number
3
return: 3 *
number
4
return: 4 *
number
5
return: 5 *
1
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
Control is returned to the
calling method.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
number
3
return: 3 *
number
4
return: 4 *
number
5
return: 5 *
2
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The calling method now can
return a value, in this case
( 3 * 2 ) or 6.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
number
3
return: 3 *
number
4
return: 4 *
number
5
return: 5 *
2
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
Control is returned to the
calling method.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
number
4
return: 4 *
number
5
return: 5 *
6
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The calling method now can
return a value, in this case
( 4 * 6 ) or 24.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
number
4
return: 4 *
number
5
return: 5 *
6
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
Control is returned to the
calling method.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
number
5
return: 5 *
answer = fact.factorial(testNumber);
24
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
The last factorial
method call will return
control to the main method.
The method will return the
value of (5 * 24) or 120
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
number
5
return: 5 *
answer = fact.factorial(testNumber);
24
System.out.println(testNumber + "! = " +
testNumber
5
answer
-
answer);
}
Stepping through the Code
answer is assigned the
value returned by the
factorial method call,
120.
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer 120
answer);
}
Stepping through the Code
The following is
output to the screen:
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1;
5! = 120
else
return number * factorial(number - 1);
}
public static void main (String args[]) {
FactorialExample fact = new
FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " +
testNumber
5
answer 120
answer);
}
Summary
 Recursion is a powerful programming technique that
provides elegant solutions to certain problems.
 Recursion is a technique in which a method calls itself
either directly, or indirectly through another method.
 Base cases are usually the simplest cases a recursive
method can solve.
Summary
 If the method is called with a base case, it returns a
result. If the methods is called with something other
than the base case, the recursive method will decide
what part it can accomplish, and then call itself to solve
the rest of the problem.
 The best way to understand recursion is to step through
the code.