CHAPTER 10

Recursion

2

Recursive Thinking

Recursion is a programming technique in which a method can call itself to solve a problem

A recursive definition is one that describes something in terms of simpler versions of itself.

3

Recursive Definitions

Ordering property: "Simpler" means that we can order the versions by some criterion.

Simplest version: Minimal / base case of the recursive object/procedure

4

Recursive Definitions - Examples Consider the following list of numbers:

24, 88, 40, 37

Such a list can be defined recursively:

A LIST is a: numberor a: number comma LIST

That is, a LIST can be a number, or a number followed by a comma followed by a LIST

The concept of a LIST is used to define itself

5

FIGURE 10.1 Tracing the recursive definition of a list

6

Recursive Definitions - Examples

Consider the function f(n) = an.

Initial condition: f(0) = 1

Recursive rule:f(n) = a * f(n-1)

7

Recursive Definitions - Examples

Consider the function f(n) = n!n! = 1 * 2 * 3 * … * (n-2) * (n-1) * n 0! = 1 by definition

Initial condition: f(0) = 1

Recursive rule:f(n) = n * f(n-1)

8

Recursive Methods in Programming 1

A recursive method must have at least one base, or stopping, case

Each successive call to itself must be a "smaller version of itself" so that a base case is eventually reached.

9

Recursive Methods in Programming - Example

boolean BinarySearch(A, Start, End, P)find M = A[middle]

If (M = P) return true <<<<< the baseelse if (End - Start = 0) return false <<<<< the base

else if (P > M) BinarySearch(A, middle+1, End, P) else BinarySearch(A, Start, middle, P)

Here the terminating condition is End - Start = 0 or M = P

10

Recursive Methods in Programming 2

A method in Java can invoke itself; if set up that way, it is called a recursive method

The code of a recursive method must be structured to handle both the base case and the recursive case

Each call sets up a new execution environment, with new parameters and new local variables

As always, when the method completes, control returns to the method that invoked it

11

How to design a recursive method 1

A recursive method must have: one or more base cases one or more recursive cases which make the

problem smaller General Idea:

determine your base cases first (What can you solve?)

determine how to simplify the problem to get to a base case

12

How to design a recursive method 2

The base case identifies a condition of the parameters in which the result can be immediately computed. 

The recursive case identifies the situation, in which the result must be expressed in terms of the solution to a simpler problem. 

13

How to design a recursive method 3

To distinguish between the base case and the recursive case, a recursive method always can be expressed in the form of an if...else statement as follows:

    if (base case)        // compute and return the result directly     else       // re-call the method to obtain the solution to a       // simpler problem, and compute the result from

// that solution

14

Infinite Recursion

All recursive definitions must have a non-recursive part. If they don't, there is no way to terminate the recursive path

A definition without a non-recursive part causes infinite recursion.

This problem is similar to an infinite loop -- with the definition itself causing the infinite "looping"

15

How to avoid infinite recursion

Take special care to ensure that the base case is properly implemented.

Make sure that each subsequent recursive call represents progress toward the base case

16

Recursive Programming – Example 2

Consider the problem of computing the sum of all the numbers between 1 and N, inclusive

If N is 5, the sum is 1 + 2 + 3 + 4 + 5 This problem can be expressed recursively as:

The sum of 1 to N is N plus the sum of 1 to N-1

17

FIGURE 10.2 The sum of the numbers 1 through N, defined recursively

18

Recursive Programming – the code

public int sum (int num){ int result; if (num == 1) result = 1; else result = num + sum(num-1); return result;}

19

FIGURE 10.3 Recursive calls to the sum method

20

Indirect Recursion

A method invoking itself is considered to be direct recursion

A method could invoke another method, which invokes another, etc., until eventually the original method is invoked again

For example, method m1 could invoke m2, which invokes m3, which invokes m1 again

This is called indirect recursion

It is often more difficult to trace and debug

21

FIGURE 10.4 Indirect recursion

22

Verifying Recursive Methods

Trace the recursive method – difficult

Draw diagram of the recursive calls – can be done for small examples only

Use a method based on algorithm specification

23

Verifying Recursive Methods

Develop a precise specification of what the algorithm has to do

Check the base case – make sure the result meets the specification

Check each recursive case and make sure it is for a smaller version of the problem, so that eventually the base case will be executed

Assuming that the recursive call returns correct results, check to see if the recursive case meets the specifications

24

Recursion vs. Iteration

Just because we can use recursion to solve a problem, doesn't mean we should For instance, we usually would not use recursion

to solve the sum of 1 to N The iterative version is easier to understand

(in fact there is a formula that is superior to both recursion and iteration in this case)

You must be able to determine when recursion is the correct technique to use

25

Recursion vs. Iteration

Every recursive solution has a corresponding iterative solution For example, the sum of the numbers between 1

and N can be calculated with a loop

Recursion has the overhead of multiple method invocations

However, for some problems recursive solutions are often more simple and elegant than iterative solutions

26

When to Use Recursion

Recursion is preferred when each next call substantially reduces the input size

Example: Recursive sum calls reduce the input by one:

result = num + sum(num-1); Recursive binary search reduces the input by a

factor of 2 if (P > M) BinarySearch (A, middle+1, End, P) else BinarySearch (A, Start, middle, P)

27

Example: Computing an

Compute 230 with 7 multiplications only (((22 *2 )2 * 2)2 *2)2

Iteration will require 29 multiplications Recursive solution:

int pow(a,N) if N = 1 return a // terminating condition else

if N is even return pow(a, N/2) * pow(a,N/2) else return a*pow(a,N/2)*pow(a,N/2)

28

Analysis of recursive methods

Solving recurrence relationspublic int sum (int num)

{ if (num == 1) return 1;

else return num + sum(num-1); }

Recurrence relation: T(N) = T(N-1) + 1 The time to compute the sum of N integers is

equal to the time to compute the sum of N-1 integers plus a constant

29

Solving recurrence relations T(N) = T(N-1) + 1 Telescoping:

T(N) = T(N-1) + 1 T(N-1) = T(N-2) +1 ….. T(2) = T(1) +1

Add the left and the right sidesT(N) + T(N-1) + …. T(2) = T(N-1) + T(N-2) +…T(1) + 1 + 1 + …. + 1After crossing the equal terms

T(N) = T(1) + 1 + 1 + … + 1 = NTherefore the complexity is O(N), same as with iteration