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

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.

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

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.

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.

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.

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.

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.

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.

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.

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

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

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 return number * factorial(number - 1); } public static void main (String args[]) { FactorialExample fact = new FactorialExample(); We will use 5! as our test case.

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.

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

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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 -

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

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

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.