chapter 02 recursion compiled by: dr. mohammad omar alhawarat

CHAPTER 02

Recursion Compiled by: Dr. Mohammad Omar Alhawarat

2

Recursive Definitions

Consider the following list of numbers:24, 88, 40, 37

Such a list can be defined recursively:A LIST is a: number

or 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

3

Tracing the recursive definition of a list

LIST: number comma LIST

24 , 88, 40, 37

number comma LIST

88 , 40, 37

number comma LIST

40 , 37

number

37

4

What Is Recursion?

It is a problem-solving process Breaks a problem into identical but

smaller problems Eventually you reach a smallest problem

Answer is obvious or trivial Using that solution enables you to solve

the previous problems Eventually the original problem is solved

5

Recursive Thinking

Recursion is a programming technique in which a method can call itself in order to fulfill its purpose

A recursive definition is one which uses the word or concept being defined in the definition itself

In some situations, a recursive definition can be an appropriate way to express a concept

Before applying recursion to programming, it is best to practice thinking recursively

6

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”

The non-recursive part often is called the base case

7

Parts of a Recursive Definition

Every recursive definition contains two parts:

a base case, which is non-recursive and, consequently, terminates the recursive application of the rule.

a recursive case, which reapplies a rule.

8

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

9

Direct vs. Indirect Recursion

m1 m2 m3

m1 m2 m3

m1 m2 m3

10

Phases of Recursion

Forward Phase:Every recursion has a forward phase in which a call at every level, except the last, spins off a call to the next level, and waits for the latter call to return control it.

Backward Phase: Every recursion has a backtracking phase in which a call at every level, except the first, passes control back to the previous level, at which point the call waiting at the previous level wakes up and resumes its work.

11

Examples: Simple problems

Summation Factorial Fibonacci

12

Summation

1221

21

1

3

1

2

1

1

1

1

NNN

iNNN

iNN

iNi

N

i

N

i

N

i

N

i

13

The sum of 1 to N, defined recursively

int sum (int num){ int result;

if (num == 1) result = 1; else result = num + sum(num-1);

return result;}

Base case

Recursive case

14

Recursive calls to the sum method

main

sum

sum

sum

sum

result = 4 + sum(3)

sum(4)

sum(3)

sum(2)

sum(1)

result = 1

result = 3 + sum(2)

result = 2 + sum(1)

15

Factorial

Mathematical formulas are often expressed recursively

N!, for any positive integer N, is defined to be the product of all integers between 1 and N inclusive

This definition can be expressed recursively:1! = 1N! = N * (N-1)!

A factorial is defined in terms of another factorial until the base case of 1! is reached

16

Factorial Function

N is 1 x 2 x 3 x ... x N – 1 x N

17

Computing the Factorial A recursive program implements a recursive definition.

The main work in writing a recursive method to solve a specific problem is to define base cases.

18

Computing the Factorial (Cont.)

19

Fibonacci Sequence

fibn – 1 + fibn – 2, if n > 1 recursive case

fibn =0, if n == 0 base case1, if n == 1 base case

1-20

Fibonacci Sequence

Definition of F(4) spins off two chains of recursion, one on F(3) and another on F(2).

Every chain either ends in F(0) or F(1)

21

Computing the Fibonacci Sequence

1-22

Computing the Fibonacci Sequence (Cont.)

Every call waits on two subsequent calls. These waits are not

simultaneous. For every call there is a

wait-wakeup-wait-wakeup cycle. Except the F(0) and

F(1). There are two forward

phases and two backtracking phases.

23

Avoiding Recursion

int fibo(int n){

if (n < 2) return 1; else return fibo(n-1) + fibo(n-2);}

24

Avoiding Recursion

25

Avoiding Recursion

int fibo(int n){ int f[n]; f[0]=0; f[1]=1;

for (int i=2; i<=n; i++) f[i] = f[i-1] + f[i-2]; return f[n];}

26

A Simple Solution to a Difficult Problem

The Towers of Hanoi

26

1-27

Towers of Hanoi: An Application

There are three towers or pegs, A, B, and C, and a pile of disks of various sizes. The disks start on peg A. Move all the disks from peg A

to C, using B as an intermediate.

(a) only one disk can be moved at a time.

(b) a larger disk can never go on top of a smaller one.

28

Towers of Hanoi: Base cases

The smallest instance of the problem is when there is only one disk in the stack. Simply move the disk from peg A to C.

With 2 disks: Top disk moves to B Bottom disk moves to C. Top disk moves from B to C.

1-29

Towers of Hanoi: Recursive cases

With three disks: We move two disks out of

the way from A to B. We move the bottom disk

from A to C. We move the two disks

from B to C. We are not allowed to move

two disks at a time. Sub-problems requires us to

move two disks from one beg to another, which we already know how to do.

30

Towers of Hanoi: Recursive cases(Cont.) Two-disk problem moved two disks from

A to C. Three-disk problem, the first two-disk sub-

problem moves disks from A to B. Second two-disk sub-problem moves disks

form B to C. Providing the source destination, and

intermediate pegs can generalize the sub-problem.

31

Towers of Hanoi: All together

Recursive definition of towers of Hanoi solution for any n. Solve the towers of Hanoi problem for n – 1,

with source peg A, destination peg B, intermediate peg C.

Move a disk from A to C. Solve the towers of Hanoi problem for n – 1,

with source peg B, destination peg C, intermediate peg A.

1-32

Towers of Hanoi: An example

• The sequence of moves for solving the Towers of Hanoi problem with three disks.

Continued →

1-33

Towers of Hanoi: An example (Cont.)

• (Continued) The sequence of moves for solving the Towers of Hanoi problem with three disks.

1-34

Towers of Hanoi: An example (Cont.)

• (Continued) The smaller problems in a recursive solution for four disks

35

Towers of Hanoi: The algorithm

Algorithm to solve Towers of Hanoi Puzzle

Algorithm solveTowers (numberOfDisks, startPole, tempPole, endPole)if (numberOfDisks == 1)

Move disk from startPole to endPole else {

solveTowers (numberOfDisks - 1, startPole, endPole, tempPole) Move disk from startPole to endPole solveTowers (numberOfDisks - 1, tempPole, startPole, endPole)

}

35

1-36

Recursion vs. Iteration

Comparison of elements of a loop and a recursive function

Loop Recursive Method

loop control variable method input

loop exit condition base case

loop entry condition recursive case

loop body method body

37

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

38

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

39

Drawbacks of Recursion

Stack space that is used to implement it. Every recursive method call produces a

new instance of the method, with a new set of local variables (including parameters).

Computing the factorial of a number. Local information pertaining to each of the calls

to fact(N), fact(N-1), etc. all the way down to fact(2) is stored on stack.

fact (N) would consume O(N) worth of stack space.

40

Drawbacks of Recursion (Cont.)

Certain computations may be performed redundantly. The Fibonacci sequence.

In computing F(4), F(2) is computed twice. F(5)?

F(3) is computed twice, which involves a computation of F(2), and there is another computation of F(2) by itself.

Things thus get worse as we recursively compute the Fibonacci sequence for bigger and bigger numbers.

Not to mention the stack space used.

41

Drawbacks of Recursion (Cont.)

One has to weigh the simplicity of code delivered by recursion against its drawbacks. When iterative solution is obvious. There are several problems for which such

iterative solutions are not obviously forthcoming.

42

Summary

Defining the base case is vital. Building on the base case(s) to solve a

problem results in defining the recursive case.

It is not always right to use recursive solutions. Applying recursive on simple problems may result in inefficiency in terms of time and redundancy (Fibonacci).

Recursion is simple, efficient, and elegant solution if applied to the right problem (Towers of Hanoi).