1. Understanding Recursion

2. Introduction
Recursion is a powerful programming technique that provides elegant solutions to certain problems.

3. 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.

4. A Mathematical Example - Factorials
Mathematical formulas often are expressed recursively.

5. A Mathematical Example - Factorials
Mathematical formulas often are expressed recursively.
In the following example, we will look in depth at factorials.

6. 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! = = 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.

7. A Closer Look n! = n * (n-1)! for n > 0; 0! = 1
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.

8. A Closer Look n! = n * (n-1)! for n > 0; 0! = 1
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.

9. Base Cases
Base cases are important. A recursive method can solve only a base case.

10. 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.

11. 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.

12. 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.

13. Converting to Code For simplicity, we will add a main method.
n! = n · (n-1)! for n > 0; 0! = 1
public class FactorialExample { }
For simplicity, we will add a main method.

14. Converting to Code For simplicity, we will add a main method.
n! = n · (n-1)! for n > 0; 0! = 1
public class FactorialExample {
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample(); }
For simplicity, we will add a main method.
The main method will create a FactorialExample object.

15. Converting to Code We’ll add our recursive method, factorial.
n! = n · (n-1)! for n > 0; 0! = 1
public class FactorialExample {
public long factorial(long number) { }
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
We’ll add our recursive method, factorial.

16. Converting to Code
n! = n · (n-1)! for n > 0; 0! = 1
public class FactorialExample {
public long factorial(long number) { }
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
We now need to identify the base case; that is, the case the method factorial can solve without calling itself.

17. Converting to Code
n! = n · (n-1)! for n > 0; 0! = 1
public class FactorialExample {
public long factorial(long number) { }
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
In the formula above, we can use 0! = 1 as the base case. 0! is the simplest case.

18. Converting to Code
n! = n · (n-1)! for n > 0; 0! = 1
public class FactorialExample {
public long factorial(long number) {
if (number == 0)
return 1; }
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
In the formula above, we can use 0! = 1 as the base case. 0! is the simplest case.

19. Converting to Code
n! = n · (n-1)! for n > 0; 0! = 1
public class FactorialExample {
public long factorial(long number) {
if (number == 0)
return 1; }
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
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.

20. Converting to Code
n! = n · (n-1)! for n > 0; 0! = 1
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1; }
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
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.

21. Converting to Code Now, we need to add recursion.
n! = n · (n-1)! for n > 0; 0! = 1
public class FactorialExample {
public long factorial(long number) {
if (number <= 1)
return 1; }
public static void main (String args[]) {
FactorialExample fact =
new FactorialExample();
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

22. Converting to Code Now, we need to add recursion.
n! = n · (n-1)! for n > 0; 0! = 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();
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

23. 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();

24. 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();
We will use 5! as our test case.

25. 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();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + “! = “ + answer);
We will use 5! as our test case,
and modify main slightly.

26. 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);

27. 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 + "! = " + answer);
testNumber 5
answer -

28. 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 + "! = " + answer);
answer
testNumber 5 -

29. 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 5
answer
testNumber 5 -

30. 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 5
answer
testNumber 5 -

31. 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 5
number 5
answer
testNumber 5 -

32. 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 5
return: 5 *
number 5
answer
testNumber 5 -

33. 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 5
return: 5 *
number 5
answer
testNumber 5 -

34. Stepping through the Code
The factorial method is called, and another formal parameter number is created.
This time the value of number is the previous formal parameter’s value (number - 1) or 4.
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);
number 4
return: 5 *
number 5
number 5
answer
testNumber 5 -

35. 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 4
return: 5 *
number 5
number 5
answer
testNumber 5 -

36. 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); }
public static void main (String args[]) {
FactorialExample fact = new FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 4
return: 4 *
return: 5 *
number 5
number 5
answer
testNumber 5 -

37. Stepping through the Code
So, the method will return the value of number (in this case, 4), 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 4
return: 4 *
return: 5 *
number 5
number 5
answer
testNumber 5 -

38. Stepping through the Code
Another formal parameter number is created.
This time the value of number is the previous formal parameter’s value (number - 1) or 3.
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);
number 3
number 4
return: 4 *
number 5
return: 5 *
number 5
answer
testNumber 5 -

39. 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); }
public static void main (String args[]) {
FactorialExample fact = new FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
return: 3 *
number 3
number 4
return: 4 *
return: 5 *
number 5
number 5
answer
testNumber 5 -

40. 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); }
public static void main (String args[]) {
FactorialExample fact = new FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 2
return: 3 *
number 3
number 4
return: 4 *
return: 5 *
number 5
number 5
answer
testNumber 5 -

41. 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); }
public static void main (String args[]) {
FactorialExample fact = new FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
return: 2 *
number 2
return: 3 *
number 3
number 4
return: 4 *
return: 5 *
number 5
number 5
answer
testNumber 5 -

42. Stepping through the Code
with a new formal parameter.
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);
number 1
number 2
return: 2 *
return: 3 *
number 3
number 4
return: 4 *
return: 5 *
number 5
number 5
answer
testNumber 5 -

43. 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;
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);
number 1
number 2
return: 2 *
return: 3 *
number 3
number 4
return: 4 *
return: 5 *
number 5
number 5
answer
testNumber 5 -

44. Stepping through the Code
number is 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 1
number 2
return: 2 *
return: 3 *
number 3
number 4
return: 4 *
return: 5 *
number 5
number 5
answer
testNumber 5 -

45. Stepping through the Code
The method returns 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 1
return: 1
number 2
return: 2 *
return: 3 *
number 3
number 4
return: 4 *
number 5
return: 5 *
number 5
answer
testNumber 5 -

46. 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 2
return: 2 * 1
return: 3 *
number 3
number 4
return: 4 *
return: 5 *
number 5
number 5
answer
testNumber 5 -

47. 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;
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);
number 2
return: 2 * 1
return: 3 *
number 3
number 4
return: 4 *
return: 5 *
number 5
number 5
answer
testNumber 5 -

48. 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
return: 3 *
number 3 2
number 4
return: 4 *
number 5
return: 5 *
number 5
answer
testNumber 5 -

49. 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); }
public static void main (String args[]) {
FactorialExample fact = new FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
return: 3 *
number 3 2
number 4
return: 4 *
number 5
return: 5 *
number 5
answer
testNumber 5 -

50. 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 4
return: 4 * 6
number 5
return: 5 *
number 5
answer
testNumber 5 -

51. 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); }
public static void main (String args[]) {
FactorialExample fact = new FactorialExample();
long testNumber = 5;
long answer;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
number 4
return: 4 * 6
number 5
return: 5 *
number 5
answer
testNumber 5 -

52. 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
return: 5 *
number 5
number 5 24
answer
testNumber 5 -

53. 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;
answer = fact.factorial(testNumber);
System.out.println(testNumber + "! = " + answer);
return: 5 *
number 5
number 5 24
answer
testNumber 5 -

54. 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 + "! = " + answer);
testNumber 5
answer
120

55. Stepping through the Code
The following is output to the screen:
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);
5! = 120
testNumber 5
answer
120

56. 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.

57. 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.