Recursion Recursio Recursi Recurs Recur Recu Rec Re R

Methods that call themselves Consider 5! equates to 5 * 4 * 3 * 2 * 1 This is an iterative example, as is the code: public static long fact(int n) { long prod = 1; for(int i=1; i<=n; i++) prod *= i; return prod; } How would you define n! in an iterative fashion?

Methods that call themselves Consider 5! equates to 5 * 4 * 3 * 2 * 1 This is an iterative example, as is the code: public static long fact(int n) { long prod = 1; for(int i=1; i<=n; i++) prod *= i; return prod; } How would you define n! in an iterative fashion? n! = (n) * (n-1) * (n-2) * (n-3) * … * 3 * 2 * 1

n! = (n) * (n-1) * (n-2) * (n-3) * … * 3 * 2 * 1 This is a lousy mathematical definition: It doesn’t work for n==0, 1, 2, 3, 4, 5, or 6 No mathematic definition should contain “…” Consider a definition of n! that is more mathematically sound:

5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 4!

5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 4! 4! = 4 * 3!

5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 4! 4! = 4 * 3! 3! = 3 * 2!

5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 4! 4! = 4 * 3! 3! = 3 * 2! 2! = 2 * 1!

5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 4! 4! = 4 * 3! 3! = 3 * 2! 2! = 2 * 1! 1! = 1 * 0!

5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 4! 4! = 4 * 3! 3! = 3 * 2! 2! = 2 * 1! 1! = 1 * 0! 0! = 1

5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 4! 4! = 4 * 3! 3! = 3 * 2! 2! = 2 * 1! 1! = 1 * 1 = 1

5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 4! 4! = 4 * 3! 3! = 3 * 2! 2! = 2 * 1 = 2

5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 4! 4! = 4 * 3! 3! = 3 * 2 = 6

5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 4! 4! = 4 * 6 = 24

5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 24 = 120

5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 4! and 0! = 1 So what is n!...

This is a recursive definition: 5! = 5 * (4 * 3 * 2 * 1) Note that 4! = (4 * 3 * 2 * 1) 5! = 5 * 4! and 0! = 1 So what is n!... n! = n * (n-1)! and 0! = 1 This is a recursive definition: We define n-factorial by calling factorial in the next easiest state (recursive call) We tell it when to stop, 0! = 1 (terminating case)

the method MUST know when to stop, which is the terminating case. public static long fact(int n) { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } there is no loop loop-like behavior is achieved by the method calling itself inside of itself the method MUST know when to stop, which is the terminating case.

public static long fact(int n) //5 { if( n == 0) //terminating case, 0 public static long fact(int n) //5 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5)

public static long fact(int n) //5 { if( n == 0) //terminating case, 0 public static long fact(int n) //5 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4)

public static long fact(int n) //4 { if( n == 0) //terminating case, 0 public static long fact(int n) //4 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4)

public static long fact(int n) //4 { if( n == 0) //terminating case, 0 public static long fact(int n) //4 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4) = 4 * fact(3)

public static long fact(int n) //3 { if( n == 0) //terminating case, 0 public static long fact(int n) //3 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4) = 4 * fact(3)

public static long fact(int n) //3 { if( n == 0) //terminating case, 0 public static long fact(int n) //3 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4) = 4 * fact(3) = 3 * fact(2)

public static long fact(int n) //2 { if( n == 0) //terminating case, 0 public static long fact(int n) //2 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4) = 4 * fact(3) = 3 * fact(2)

public static long fact(int n) //2 { if( n == 0) //terminating case, 0 public static long fact(int n) //2 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4) = 4 * fact(3) = 3 * fact(2) = 2 * fact(1)

public static long fact(int n) //1 { if( n == 0) //terminating case, 0 public static long fact(int n) //1 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4) = 4 * fact(3) = 3 * fact(2) = 2 * fact(1)

public static long fact(int n) //1 { if( n == 0) //terminating case, 0 public static long fact(int n) //1 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4) = 4 * fact(3) = 3 * fact(2) = 2 * fact(1) = 1 * fact(0)

public static long fact(int n) //0 { if( n == 0) //terminating case, 0 public static long fact(int n) //0 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4) = 4 * fact(3) = 3 * fact(2) = 2 * fact(1) = 1 * fact(0) = 1

public static long fact(int n) //1 { if( n == 0) //terminating case, 0 public static long fact(int n) //1 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4) = 4 * fact(3) = 3 * fact(2) = 2 * fact(1) = 1 * 1 = 1

public static long fact(int n) //2 { if( n == 0) //terminating case, 0 public static long fact(int n) //2 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4) = 4 * fact(3) = 3 * fact(2) = 2 * 1 = 2

public static long fact(int n) //3 { if( n == 0) //terminating case, 0 public static long fact(int n) //3 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4) = 4 * fact(3) = 3 * 2 = 6

public static long fact(int n) //4 { if( n == 0) //terminating case, 0 public static long fact(int n) //4 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * fact(4) = 4 * 6 = 24

public static long fact(int n) //5 { if( n == 0) //terminating case, 0 public static long fact(int n) //5 { if( n == 0) //terminating case, 0! = 1 return 1; return n * fact(n – 1); //recursive call, n! = n * (n-1)! } fact(5) = 5 * 24 = 120

Recursive thinking First consider the terminating case: What is the most simple possible input such that the method already knows the answer? For factorial, the easiest number to find the factorial of is zero. fact(0) should return 1. Then, given complex input, what would be considered “one-step-easier”. For factorial, fact(5) would be complex. One-step-easier than fact(5) would be fact(4). Now, how can you define the solution given complex input by calling the method given “one-step-easier”? For factorial, fact(5) is equivalent to 5 * fact(4) Lastly, replace the complex input with the argument name. If fact(5) = 5 * fact(4), then fact(n) = n * fact(n-1)

void recursion public static void doStuff(int n) { if(n >= 0) System.out.println(n); doStuff(n – 2); } Note: terminating case not implicitly stated, but… If n < 0, the if statement is skipped and the method ends. If we keep subracting 2 from n, the condition will eventually be false and the method can stop.

void recursion public static void doStuff(int n) { if(n >= 0) System.out.println(n); doStuff(n – 2); } doStuff(6) output

void recursion public static void doStuff(int n) { if(n >= 0) System.out.println(n); doStuff(n – 2); } doStuff(6) SOP(6) doStuff(4) output 6

void recursion public static void doStuff(int n) { if(n >= 0) System.out.println(n); doStuff(n – 2); } doStuff(6) SOP(6) doStuff(4) output 6

void recursion public static void doStuff(int n) { if(n >= 0) System.out.println(n); doStuff(n – 2); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) output 6 4

void recursion public static void doStuff(int n) { if(n >= 0) System.out.println(n); doStuff(n – 2); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) output 6 4

void recursion public static void doStuff(int n) { if(n >= 0) System.out.println(n); doStuff(n – 2); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) SOP(2) doStuff(0) output 6 4 2

void recursion public static void doStuff(int n) { if(n >= 0) System.out.println(n); doStuff(n – 2); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) SOP(2) doStuff(0) output 6 4 2

void recursion public static void doStuff(int n) { if(n >= 0) System.out.println(n); doStuff(n – 2); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) SOP(2) doStuff(0) SOP(0) doStuff(-2) output 6 4 2

void recursion public static void doStuff(int n) { if(n >= 0) System.out.println(n); doStuff(n – 2); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) SOP(2) doStuff(0) SOP(0) output 6 4 2 doStuff(-2)

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) output

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) doStuff(4) //we will, in order, call //doStuff(4) and then //print the 6. //But we must finish //doStuff(4) before we //print the 6 SOP(6) output

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) SOP(6) doStuff(4) output

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) SOP(6) doStuff(4) doStuff(2) //we will, in order, call //doStuff(2) and then //print the 4. //But we must finish //doStuff(2) before we //print the 4 SOP(4) output

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) output

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) doStuff(0) //we must finish //doStuff(0) before //we print the 2 SOP(2) output

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) SOP(2) doStuff(0) output

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) SOP(2) doStuff(0) doStuff(-2) SOP(0) output

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) SOP(2) doStuff(0) SOP(0) doStuff(-2) output

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) SOP(2) doStuff(0) SOP(0) output

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) SOP(6) doStuff(4) SOP(4) doStuff(2) SOP(2) output 2

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) SOP(6) doStuff(4) SOP(4) output 2 4

void - code after recursive call public static void doStuff(int n) { if(n >= 0) doStuff(n – 2); System.out.println(n); } doStuff(6) SOP(6) output 2 4 6

Project 12_1 The book says: gcd(a, b) = b, when a = 0 gcd(a, b) = gcd(b, a % b), when a > 0 It should be: gcd(a, b) = a, when b = 0