M180: Data Structures & Algorithms in Java Recursion Arab Open University

Recursive thinking Recursion: a programming technique in which a method can call itself to solve a problem recursive definition: one which uses the concept being defined in the definition itself In some situations, a recursive definition can be an appropriate or elegant way to express a concept. Before applying recursion to programming, it is best to practice thinking recursively

A recursive algorithm Consider the task of finding out what place you are in a long line of people. If you cannot see the front of the line, you could ask the person in front of you. To answer your question, this person could ask the person in front of him/her, and so on.

A recursive algorithm Once the front person answers their place in line (first), this information is handed back, one person at a time, until it reaches you. This is the essence of recursive algorithms; many invocations of the same method each solve a small part of a large problem.

Infinite Recursion All recursive definitions have to have a non-recursive part If they didn't, there would be no way to terminate the recursive path Such a definition would cause infinite recursion This problem is similar to an infinite loop, but the non- terminating "loop" is part of the definition itself The non-recursive part is often called the base case

Recursion Java's looping constructs make implementing this process easy. sum(1) = 1 sum(N) = N + sum(N - 1) if N > 1 Consider what happens when the definition is applied to the problem of calculating sum(4): sum(4) = 4 + sum(3) = 4 + 3 + sum(2) = 4 + 3 + 2 + sum(1) = 4 + 3 + 2 + 1 The fact that sum(1) is defined to be 1 without making reference to further invocations of sum saves the process from going on forever and the definition from being circular.

Factorial example The factorial for any positive integer N, written N!, is defined to be the product of all integers between 1 and N inclusive // not recursive public static long factorial(int n) { long product = 1; for (int i = 1; i <= n; i++) { product *= i; } return product;}

Recursive factorial factorial can also be defined recursively: A factorial is defined in terms of another factorial until the basic case of 0! is reached // recursive public static long factorial(int n) { if (n == 0) { return 1; } else { return n * factorial(n - 1); }}

Recursive factorial 5! 5 * 4! 4 * 3! 3 * 2! 2 * 1! 1 2 6 24 120

Recursion vs. iteration every recursive solution has a corresponding iterative solution For example, N ! can be calculated with a loop For some problems, recursive solutions are often more simple and elegant than iterative solutions You must be able to determine when recursion is appropriate

Recursive Programming Consider the problem of computing the sum of all the numbers between 1 and any positive integer N This problem can be recursively defined as:

Recursive Programming // This method returns the sum of 1 to num public int sum (int num) { int result; if (num == 1) result = 1; else result = num + sum (n-1); return result; }

Recursive Programming main sum sum(3) sum(1) sum(2) result = 1 result = 3 result = 6

Fibonacci Recursion Consider the definition of Fibonacci numbers below. The first and second numbers in the Fibonacci sequence are 1. Thereafter, each number is the sum of its two immediate predecessors, as follows: 1 1 2 3 5 8 13 21 34 55 89 144 233 ... Or in other words: fibonacci(1) = 1 fibonacci(2) = 1 fibonacci(N) = fibonacci(N - 1) + fibonacci(N - 2) if N > 2 This is a recursive definition, and it is hard to imagine how one could express it no recursively.

Fibonacci Recursion As a second example of recursion, below is a method that calculates Fibonacci numbers: int fibonacci (int n){ if (n <= 2) return 1; else return fibonacci (n - 1) + fibonacci (n - 2); }

Malformed Recursive Method Here is a subtler example of a malformed recursive method: This method works fine if n is odd, but when n is even, the method passes through the stopping state and keeps on going. int badMethod (int n){ if (n == 1) return 1; else return n * badMethod(n - 2); }

Guidelines for Writing Recursive Methods A recursive method must have a well-defined termination or stopping state. For the factorial method, this was expressed in the lines: The recursive step, in which the method calls itself, must eventually lead to the stopping state. For the factorial method, the recursive step was expressed in the lines: if (n == 1) return 1; else return n * factorial(n - 1);

Guidelines for Writing Recursive Methods Because each invocation of the factorial method is passed a smaller value, eventually the stopping state must be reached. Had we accidentally written: the method would describe an infinite recursion. Eventually, the user would notice and terminate the program, or else the Java interpreter would run out memory, and the program would terminate with a stack overflow error. else return n * factorial(n + 1);

Number of Zeros in a Number Example: 2030 has 2 zeros If n has two or more digits the number of zeros is the number of zeros in n with the last digit removed plus an additional 1 if the last digit is zero Examples: number of zeros in 20030 is number of zeros in 2003 plus 1 number of zeros in 20031 is number of zeros in 2003 plus 0 recursive

numberOfZeros Recursive Design numberOfZeros in the number N K = number of digits in N Decomposition: numberOfZeros in the first K - 1 digits Last digit Composition: Add: numberOfZeros in the first K – 1 digits 1 if the last digit is zero Base case: N has one digit (K = 1)

numberOfZeros Method public static int numberOfZeros(int n) { int zeroCount; if (n==0) zeroCount = 1; else if (n < 10) zeroCount = 0; else if (n%10 == 0) zeroCount = numberOfZeros(n/10) + 1; else // n%10 != 0 zeroCount = numberOfZeros(n/10); return zeroCount; } Which is (are) the base case(s)? Why? Decompostion, Why? Composition, why?

Execution Trace (decomposition) public static int numberOfZeros(int n) { int zeroCount; if (n==0) zeroCount = 1; else if (n < 10) zeroCount = 0; else if (n%10 == 0) zeroCount = numberOfZeros(n/10) + 1; else // n%10 != 0 zeroCount = numberOfZeros(n/10); return zeroCount; } Execution Trace (decomposition) Each method invocation will execute one of the if-else cases shown at right. numberOfZeros(2005) numberOfZeros(200) 5 numberOfZeros(20) 0 numberOfZeros(2) 0

Execution Trace (composition) public static int numberOfZeros(int n) { int zeroCount; if (n==0) zeroCount = 1; else if (n < 10) zeroCount = 0; else if (n%10 == 0) zeroCount = numberOfZeros(n/10) + 1; else // n%10 != 0 zeroCount = numberOfZeros(n/10); return zeroCount; } Execution Trace (composition) Recursive calls return numberOfZeros(2005)->2 numberOfZeros(200)->2 5->0 numberOfZeros(20)->1 0->1 numberOfZeros(2)->0 0->1 + + +