A Different Solution alternatively we can use the following

algorithm:1. if n == 0 done, otherwise

I. print the string onceII. print the string (n – 1) more times

1

Recursion a method that calls itself is called a recursive

method a recursive method solves a problem by

repeatedly reducing the problem so that a base case can be reached

printIt("*", 5)*printIt("*", 4)**printIt("*", 3)***printIt("*", 2)****printIt("*", 1)*****printIt("*", 0) base case*****

2

Notice that the number of timesthe string is printed decreasesafter each recursive call to printIt

Notice that the base case iseventually reached.

Infinite Recursion if the base case(s) is missing, or never

reached, a recursive method will run forever (or until the computer runs out of resources)

printIt("*", 1)* printIt("*", 0)** printIt("*", -1)*** printIt("*", -2) ...........

3

Rabbits

4

Month 0: 1 pair 0 additional pairs

Month 1: first pairmakes another pair

1 additional pair

Month 2: each pairmakes another pair;oldest pair dies

1 additional pair

Month 3: each pairmakes another pair;oldest pair dies

2 additional pairs

Fibonacci Numbers the sequence of additional pairs

0, 1, 1, 2, 3, 5, 8, 13, ...are called Fibonacci numbers

base cases F(0) = 0 F(1) = 1

recursive definition F(n) = F(n – 1) + F(n – 2)

5

Recursive Methods & Return Values a recursive method can return a value example: compute the nth Fibonacci number

6

Recursive Methods & Return Values example: write a recursive method countZeros that counts the number of zeros in an integer number n 10305060700002L has 8 zeros

algorithm:if the last digit in n is a zero

return 1 + countZeros(n / 10)else

return countZeros(n / 10)

7

don't forget to establish the base case(s) when should the recursion stop? when you reach

a single digit (not zero digits; you never reach zero digits!) base case #1 : n == 0

return 1 base case #2 : n != 0 && n < 10

return 0

8

9

countZeros Call StackcallZeros( 800410L )

10

callZeros( 800410L )

callZeros( 80041L )

callZeros( 8004L )

callZeros( 800L )

callZeros( 80L )

callZeros( 8L )

1 + 0 + 0 + 1 + 1 + 0

0 + 0 + 1 + 1 + 0

0 + 1 + 1 + 0

1 + 1 + 0

1 + 0

0

3

last in first out

Fibonacci Call Tree

11

F(5)

F(4)

F(3)

F(2)

F(1)1

F(0)0

F(1)1

F(2)

F(1)1

F(0)0

F(3)

F(2)

F(1)1

F(0)0

F(1)1

Compute Powers of 10 write a recursive method that computes 10n

for any integer value n recall:

100 = 1 10n = 10 * 10n-1

10-n = 1 / 10n

12

13

Proving Correctness and Termination to show that a recursive method

accomplishes its goal you must prove:1. that the base case(s) and the recursive calls are

correct2. that the method terminates

14

Proving Correctness to prove correctness:

1. prove that each base case is correct2. assume that the recursive invocation is correct

and then prove that each recursive case is correct

15

Correctness of printIt1. (prove the base case) If n == 0 nothing is

printed; thus the base case is correct.2. Assume that printIt(s, n-1) prints the

string s (n – 1) times. Then the recursive case prints the string s (n – 1)+1 = n times; thus the recursive case is correct.

16

Proving Termination to prove that a recursive method terminates:

1. define the size of a method invocation; the size must be a non-negative integer number

2. prove that each recursive invocation has a smaller size than the original invocation

17

Termination of printIt1. printIt(s, n) prints n copies of the string

s; define the size of printIt(s, n) to be n 2. The size of the recursive invocation

printIt(s, n-1) is n-1 (by definition) which is smaller than the original size n.

18

countZeros

19

Correctness of countZeros1. (base cases) If the number has only one digit

then the method returns 1 if the digit is zero and 0 if the digit is not zero; therefore, the base case is correct.

2. (recursive cases) Assume that countZeros(n/10L) is correct (it returns the number of zeros in the first (d – 1) digits of n). If the last digit in the number is zero, then the recursive case returns 1 + the number of zeros in the first (d – 1) digits of n, otherwise it returns the number of zeros in the first (d – 1) digits of n; therefore, the recursive cases are correct.

20

Termination of countZeros1. Let the size of countZeros(n) be d the

number of digits in the number n.2. The size of the recursive invocation

countZeros(n/10L) is d-1, which is smaller than the size of the original invocation.

21

Decrease and Conquer a common strategy for solving computational

problems solves a problem by taking the original problem

and converting it to one smaller version of the same problem note the similarity to recursion

decrease and conquer, and the closely related divide and conquer method, are widely used in computer science allow you to solve certain complex problems

easily help to discover efficient algorithms

22

Root Finding suppose you have a mathematical function f(x)

and you want to find x0 such that f(x0) = 0 why would you want to do this? many problems in computer science, science, and

engineering reduce to optimization problems find the shape of an automobile that minimizes aerodynamic

drag find an image that is similar to another image (minimize the

difference between the images) find the sales price of an item that maximizes profit

if you can write the optimization criteria as a function g(x) then its derivative f(x) = dg/dx = 0 at the minimum or maximum of g (as long as g has certain properties)

23

Bisection Method suppose you can evaluate f(x) at two points x = a and x = b such that f(a) > 0 f(b) < 0

24

x

f(x)f(a)

f(b)

'plus'

'minus'

Bisection Method evaluate f(c) where c is halfway between a

and b if f(c) is close enough to zero done

25

x

f(x)f(a)

f(b)

f(c)

'plus'

'minus'

Bisection Method otherwise c becomes the new end point (in this

case, 'minus') and recursively search the range 'plus' – 'minus'

26

x

f(x)f(a)

f(b)

'plus'

'minus'

f(c)

27

Divide and Conquer bisection works by recursively finding which half

of the range 'plus' – 'minus' the root lies in each recursive call solves the same problem (tries to

find the root of the function by guessing at the midpoint of the range)

each recursive call solves one smaller problem because half of the range is discarded bisection method is decrease and conquer

divide and conquer algorithms typically recursively divide a problem into several smaller sub-problems until the sub-problems are small enough that they can be solved directly

28