# Recursion - PowerPoint PPT Presentation

PPT – Recursion PowerPoint presentation | free to download - id: 70d273-NzhkN

The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
Title:

## Recursion

Description:

### CHAPTER TWO 2 - Nipissing University ... Recursion * – PowerPoint PPT presentation

Number of Views:16
Avg rating:3.0/5.0
Slides: 61
Provided by: niroomand
Category:
Tags:
Transcript and Presenter's Notes

Title: Recursion

1
Lecture 2
• Recursion

2
CHAPTER TWO
• Recursion A recursive function is a function
that calls itself.
• Two functions A and B are mutually recursive, if
A calls B and B calls A.Recursion can always
replace iteration (looping).
• n!
• A simple example Factorial.
• Factorial(0) 1 (By definition)
• Factorial(1) 1
• Factorial(2) 21
• Factorial(3) 321
• Factorial(4) 4321
• Factorial(5) 54321
• Factorial(n) n n-1 n-2 ... 1

3
DEFINITION OF n!
• 1 if n 0
• Factorial(n)
• n Factorial(n-1) if n gt 0
• This recursive definition needs for a recursive
implementation.

4
Recursive implementation
• int factorial (int n)
• if (n 0)
• return 1
• else
• return n factorial(n - 1)

5
How to understand recursion
• Every time a recursive function is called, thats
like it is a completely separate function.
• Just ignore the fact that this function was
called by itself.
• Specifically, if factorial calls itself, then
there are two parameters n that have NOTHING to
do with each other.

6
EXAMPLE factorial(3)
• factorial(3) n 3 calls factorial(2)
• factorial(2) n 2 calls factorial(1)
• factorial(1) n 1 calls factorial(0)
• factorial(0) returns 1 to factorial(1).
Inside factorial(1),
• 1 factorial(0) becomes 1 1
• factorial(1) returns 1 to factorial(2),
• Inside factorial(2), 2 factorial(1) becomes 2
1

7
EXAMPLE factorial(3) CONTINUED
• factorial(2) returns 2 to factorial(3).
• Inside factorial(3), 3 factorial(2) becomes 3
2
• So, inside factorial(3), the return value is 3
2 6. This is what will be returned to the
program.
• cout ltlt factorial(3) // writes 6 to the screen.

8
What problems can be recursively solved?
• The following conditions should be fulfilled
• 1 - The problem can be decomposed into several
problems such that (at least) one of them is of
the same kind as the initial problem but
simpler and all the others are easy and
• 2 - If you keep deriving simpler and simpler
problems of the same kind, you will eventually
reach an easy problem.

9
Why factorial () can be recursive?
• 1 - factorial(n) is decomposed into two problems
• A multiplication and factorial(n-1) is a problem
of
• the same kind as factorial(n), but factorial(n-1)
is
• Also simpler than factorial(n).
• 1)factorial(n) n factorial(n - 1) --- if n gt
0
• 2)factorial(n) 1 --- if n 0
• 2 - If we keep reducing the argument of
factorial( )
• more and more, eventually, we will get
factorial(0)
• which is easy to solve.

10
Factorial Illustration

cout ltlt Fact(3)
6
Return 3Fact(2) 32
Return 2Fact(1) 21
int Fact(int N) if (N 0) return 1
else return N Fact(N-1)
Return 1Fact(0) 11
Return 1
Fact(3)
11
Factorial Illustration contd
N 3 A Fact(N-1) ? Return ?

N 2 A Fact(N-1) ? Return ?
N 3 A Fact(N-1) ? Return ?
N 1 A Fact(N-1) ? Return ?
N 2 A Fact(N-1) ? Return ?
N 3 A Fact(N-1) ? Return ?
N 0 Return ?
N 1 A Fact(N-1) ? Return ?
N 3 A Fact(N-1) ? Return ?
N 2 A Fact(N-1) ? Return ?
N 0 Return 1
N 1 A Fact(N-1) ? Return ?
N 3 A Fact(N-1) ? Return ?
N 2 A Fact(N-1) ? Return ?
N 0 Return 1
N 1 A Fact(N-1) 1 Return ?
N 3 A Fact(N-1) ? Return ?
N 2 A Fact(N-1) ? Return ?
12
Factorial Illustration contd
N 0 Return 1
N 1 A Fact(N-1) 1 Return 1
N 3 A Fact(N-1) ? Return ?
N 2 A Fact(N-1) ? Return ?

N 0 Return 1
N 1 A Fact(N-1) 1 Return 1
N 3 A Fact(N-1) ? Return ?
N 2 A Fact(N-1) 1 Return ?
N 0 Return 1
N 1 A Fact(N-1) 1 Return 1
N 3 A Fact(N-1) ? Return ?
N 2 A Fact(N-1) 1 Return 2
N 0 Return 1
N 1 A Fact(N-1) 1 Return 1
N 3 A Fact(N-1) 2 Return ?
N 2 A Fact(N-1) 1 Return 2
N 0 Return 1
N 1 A Fact(N-1) 1 Return 1
N 3 A Fact(N-1) 2 Return 6
N 2 A Fact(N-1) 1 Return 2
13
Example Writing an array backwards
• Given an array of characters, and we want to
write its elements backwards to the screen, i.e.,
starting with the last character.
• Of course this can be done with a
• for (x ArraySize-1 x gt 0 --x) loop, but we
will do it recursively.
• Lets try to decompose the problem.

14
Decomposition
• 1 - Writing an array of length n can be
decomposed into writing a single character
(thats easy) and writing an array of length
n-1 backwards, which is a problem of the same
kind as writing an array of length n, but its
simpler.
• 2 - If we keep reducing the length of the array
that we have to write backwards, we will
eventually end up with an array of size 1. That
is a character, and writing a character is
easy.
• EVEN BETTER, we can go to an array of size ZERO
and then we have to do NOTHING.

15
Write the function
• Still, nothing in this description results in
something written
• backward! We refine
• An array is written backward by FIRST writing its
last
• element, and then writing the array that is left
backwards. If
• we come down to an array of size 0, we do
nothing.
• void writebackward(char S, int size)
• if (size gt 0)
• cout ltlt Ssize-1
• writebackward(S, size-1)

16
Execute the function
• Lets trace through this with the following
• example
• Assume that ST contains the characters C A T.
• writebackward(ST, 3) is now called.
• Within writebackward( ) we have therefore

ST
A
T
3
C
17
Step by step
• cout ltlt S3-1 will send to the screen T
• Then comes the recursive call to
• writebackward(S,2)
• Note that S is never changed in the process.
• writebackward(S,2) will first do
• cout ltlt S2-1 which will write to screen A
• Then comes the recursive call to
• writebackward(S,1)
• writebackward(S,1) will first do
• cout ltlt S1-1 which will write to screen C
• Then comes the recursive call to

18
Last step
• writebackward(S,0)
• Writebackward(S,0) will do NOTHING.
• Note that we have already written TAC to the
screen.
• Note that the program does not end here.
• Take a look back at the code of
• writebackward( ).
• You see that NOTHING is done in
• writebackward( ) AFTER the recursive call.

19
writebackward( ) Return Path
• writebackward(S,0) returns to
writebackward(S,1)
• writebackward(S,1) has nothing left to do,
• returns to its caller, writebackward(S,2).
• writebackward(S,2) has nothing left to do,
• returns to its caller, writebackward(S,3).
• When writebackward(S,3) returns, the program
• is finished.

20
WriteBackWard(S, size) 20
S cat Size 3
S cat Size 2
S cat Size 3
S cat Size 1
S cat Size 2
S cat Size 3
S cat Size 0
S cat Size 1
S cat Size 2
S cat Size 3
S cat Size 0
S cat Size 1
S cat Size 2
S cat Size 3
S cat Size 0
S cat Size 1
S cat Size 2
S cat Size 3
S cat Size 0
S cat Size 1
S cat Size 2
S cat Size 3
21
Another solution
• Another solution to the writeback problem
• void writeback(char S, int size, int pos)
• if (pos lt size)
• writeback(S, size, pos1)
• cout ltlt Spos

22
Initial call
• We need to call this as follows
• Assume again that ST contains the characters
• C A T
• writeback(ST, 3, 0)
• Note that this procedure does SOMETHING
• after the recursive call. This is harder.

23
Nothing happens at the beginning
• Inside of writeback(ST, 3, 0) nothing happens
• before the recursive call. The recursive call
• will be
• writeback(S, 3, 1)

24
Nothing
• Inside of writeback(S, 3, 1) nothing happens
• before the recursive call. The recursive call
• will be writeback(S, 3, 2).
• Inside of writeback(S, 3, 2) nothing happens
• before the recursive call. The recursive call
• will be writeback(S, 3, 3).

25
writeback( ) Return Path
• writeback(S, 3, 3) will not do anything,
because
• the IF condition evaluates to FALSE.
• writeback(S, 3, 3) returns to writeback(S, 3,
2).
• writeback(S, 3, 2) sends T to the screen.
• writeback(S, 3, 2) returns to writeback(S, 3,
1).
• writeback(S, 3, 1) sends A to the screen.
• writeback(S, 3, 1) returns to writeback(S, 3,
0).
• writeback(S, 3, 0) sends C to the screen.
• writeback(S, 3, 0) returns to the main program.

26
WriteBackWard(S)
WriteBackWard(S)
WriteBackWard(S minus last character)
void WriteBackWard(char S) cout ltlt"Enter
WriteBackWard with string " ltlt S ltlt endl if
(strlen(S)0) else cout ltlt "About to write
last character of string" ltlt S ltlt endl cout
ltltSstrlen(S)-1ltltendl Sstrlen(S)-1'\0'
WriteBackWard(S) cout ltlt "Leave
WriteBackWard with string" ltlt S ltlt endl
27
WriteBackWard(S)
S cat
S ca
S cat
S c
S ca
S cat
S
S c
S ca
S cat
S
S c
S ca
S cat
S
S c
S ca
S cat
S
S c
S ca
S cat
28
WriteBackWard(S)
Output stream Enter WriteBackWard with string
cat About to write last character of string
cat t Enter WriteBackWard with string ca About
to write last character of string ca a Enter
WriteBackWard with string c About to write last
character of string c C Enter WriteBackWard with
string About to write last character of
string Leave WriteBackWard with string Leave
WriteBackWard with string c Leave WriteBackWard
with string ca Leave WriteBackWard with string
cat
29
POWER
• Xn 1 IF n 0 Base Case
• Xn XX(n-1) IF n gt 0 Recursive Case
• This can be translated easily into C.
• However, we can do better
• Xn 1 IF n 0
• Xn X square of X(n / 2) IF n is odd
• Xn square of X(n / 2) IF n is even

30
The function
• int power(int X, int N)
• if (N 0)
• return 1
• else
• int HalfPower power(X, N/2)
• if (N 2 0)
• return HalfPower HalfPower // Even n
• else
• return X HalfPower HalfPower // Odd n

31
FIBONACCI SEQUENCE
• A sequence of numbers is defined as follows
• The first number is 1. The second number is 1.
• Every other number is the sum of the two
• numbers before it.
• 1 1 2 3 5 8 13 21 34 55 89
• fib(1) 1 Base Case
• fib(2) 1 Base Case
• fib(n) fib(n-1) fib(n-2) n gt 2
• This is a recursion that uses TWO base cases, and
it breaks down a problem into TWO simpler
problems of the same kind.

32
The Function
• int fib(int n)
• if (n lt 2)
• return 1
• else
• return fib(n-1) fib(n-2)
• The recursive implementation is, however,
TERRIBLY inefficient, and is not recommended.
• fib(7) will call fib(3) 5 times! What a waste!

33
An (artificial) example with rabbits.
• - Rabbits never die.
• - Rabbits always give birth to twins, male and
female.
• - A couple of rabbits give birth to twins at the
first day of every month, starting at age 3
months.

34
The couples of rabbits are Fibonacci numbers
• Month 1 Couples1 Adam, Eve
• 3 2 AE and twins 1
• 4 3 AE twins 1, twins 2
• 5 5 AE, twins 1, twins 2
twins 3 (from AE) and twins 4 (from
twins 1)
• 6 8 AE, twins 1-4
• twins 5 (from AE), twins 6 (from 1),
twins 7 (from 2)
• Surprise!? These are the Fibonacci numbers.

35
• We want to make a chain out of pieces of Lead and
Plutonium.
• The chain is supposed to be of length n.
• However, there is a problem if we put two pieces
of Plutonium next to each other, the whole chain
will explode.
• How many safe chains are there?
• (Note These are linear chains.)

36
Analysis
• C(n) Number of Safe Chains of length n.
• L(n) The number of safe chains of length n that
END with a piece of lead.
• P(n) The number of safe chains of length n that
END with a piece of Plutonium.
• Example Length 3
• s LLL s PLL
• s LLP s PLP
• s LPL u PPL
• u LPP u PPP

37
Analysis contd
• The total number of chains must be the sum of
those that end with Lead and those that end with
Plutonium.
• C(n) L(n) P(n)
• Now we look at the two terms, assuming that we
add one new piece to the end.
• Given are all chains of length n-1. There are
again C(n-1) of those. To which of them can we
• Therefore, L(n) C(n-1)

38
Analysis Contd
• Given are all chains of length n-1. There are
again C(n-1) of those. To which of them can we
• Only to those that END with a piece of LEAD!!
There are L(n-1) of those. Therefore,
• P(n) L(n-1)
• C(n) L(n) P(n) C(n-1) L(n-1) C(n-1)
C(n-2)
• This is the Fibonacci formula. However, we have
slightly different base cases here.
• C(1) 2 P or L
• C(2) 3 PL of LP or LL
• Back to our example
• C(3) C(2) C(1) 3 2 5.
• Thats exactly what we had before.

39
Mr. Spocks Dilemma
• There are n planets in an unexplored planetary
system, but there is fuel for only k visits.
• How many ways are there for choosing a group of
planets to visit?
• Lets think about a specific planet, planet X.
• Either we visit X, or we dont visit X.
• C(n, k) number of ways to chose k out of n
• If we visit X, then we have n-1 choices left, but
only fuel for k-1 visits.
• If we dont visit X, then we have n-1 choices
left, but we still have fuel for k visits.

40
Analysis
• The total number of ways to choose must be the
sum of the total number of trips that include the
planet X and the total number of trips that do
not include the planet X.
• C(n, k) C(n-1, k-1) C(n-1, k)
• This is clearly recursive. Both sub-problems are
of the same kind and simpler. But are there base
cases?
• C(n-1, k-1) eventually C(n-k, 0)
• C(n-1, k) eventually C(k, k)
• (n must be greater than k, otherwise we visit all
planets, and the problem is not a problem.)

41
Last analysis
• C(k,k) 1 (There is only one way to choose k
planets out of k planets!)
• C(n,0) 1 (There is only one way to select no
planet.)
• This is a little abstract. We can use C(n, 1) n
(There are n ways to select 1 planet of n.)

42
The function
• We are ready for the recursive definition
• 1 IF k 0
• C(n,k) 1 IF k n
• C(n-1, k-1) C(n-1, k) IF 0 lt k lt n
• 0 IF k gt n
• int C(int n, int k)
• if (k gt n)
• return 0
• else if (k n)
• return 1
• else if (k 0)
• return 1
• else
• return C(n-1, k-1) C(n-1, k)

43
C(4, 2)
C(4,2) Return C(3,1) C(3,2)
C(3,1) Return C(2,0) C(2,1)
C(3,2) Return C(2,1)) C(2,2)
C(2,1) Return C(1,0) C(1,1)
C(2,1) Return C(1,0) C(1,1)
C(2,0) Return 1
C(2,2) Return 1
C(1,0) Return 1
C(1,1) Return 1
C(1,0) Return 1
C(1,1) Return 1
The recursive call that C(4,2) generates
44
A game for guessing number
• 1. I think of a number between 1 -100.
• 2. When you guess one, I tell you the number I
thought is larger or less than the one you
guessed.
• 3. Continue step 2 till you guess the right
number I though of.
• Write the number of times you guessed.

45
Binary Search
• How do you find something efficiently in a
• phone book? Open the phone book in the
• middle. If what you are looking for is in the
• first half, then ignore the second half and
• divide the first half again in the middle. Keep
• doing this until you find the page. Then
• divide the page in half, etc.

46
Binary Search
• More formally Given is A, an array of n numbers
• We want to verify whether V is in the array.
• IF n 1 THEN check whether the number is
• equal to V
• ELSE BEGIN Find the midpoint of A
• IF V is greater than the Amidpoint
• THEN Search recursively in the second half
• ELSE Search recursively in the first half

47
The function
• int bins(int A, int V, int fi, int la)
• if (fi gt la) return -1
• else
• int mid (fi la) / 2
• if (V Amid) return mid
• else if (V lt Amid)
• return bins(A,V,fi,mid-1)
• else
• return bins(A,V,mid1,la)

48
Discuss
• Notes We always pass the whole array in.
• These define the active part of the array
• - fi ... first
• - la ... last
• The return value -1 means that the number was not
found.
• Example
• Array A contains the numbers
• 0 1 2 3 4 5 6
• We will look for V 19 first, and V 21 later.
• cout ltlt bins(A,19,0,6)

1 5 9 13 17 19 23
49
The process of search
• 1 5 9 13 17 19 23 A 19 V
• fi m la
• fi m la
• Note how we quickly found it!
• 1 5 9 13 17 19 23 A , 21 V
• fi m la
• fi m la
• fi, m, la
• la fi
• Last is now before first and we stop.

50
Attentions!
• Warning Two common mistakes
• (1) CORRECT mid (fi1a)/2
• WRONG mid (Afi Ala)/2
• (2) CORRECT return bins(A, V, mid1, la)
• WRONG return bins(A, V, mid, la)

51
Efficiency on large arrays
• Note Lets say we have an array of 1,000,000
sorted numbers. (Its better if it has 220
• The first decision eliminates approx. 500,000!
• The second decision eliminates another 250,000
numbers.
• After about 20 runs through the loop, we found
it. Sequential search might need to go through
all 1,000,000 elements. (1,000,000 loops)
• What an improvement!

52
Searching the maximum in an Array
if (A has only one item) MaxArray(A) is the
item in A else if (A has more than one item)
MaxArray(A) is the maximum of MaxArray(left half
of A)
and MaxArray(right half of A)
MaxArray(A)
MaxArray(right half of A)
MaxArray(left half of A)
Recursive solution to the largest-item problem
53
Searching in Array
MaxArray(lt1,6,8,3gt) Return Max(MaxArray(lt1,6gt),
MaxArray(lt8,3gt))
MaxArray(lt1,6gt) Return Max(MaxArray(lt1gt),
MaxArray(lt6gt))
MaxArray(lt8,3gt) Return Max(MaxArray(lt8gt),
MaxArray(lt3gt))
MaxArray(lt1gt) Return 1
MaxArray(lt6gt) Return 6
MaxArray(lt8gt) Return 8
MaxArray(lt3gt) Return 3
The recursive calls that MaxArray(lt1,6,8,3gt)
generates
54
Tower of Hanoi
http//wipos.p.lodz.pl/zylla/games/hanoi3e.html
SolveTowers(Count, Source, Destination, Spare)
if (Count is 1) Move a disk directly from
source to Destination) else
SolveTowers(Count-1, Source, Spare, Destination)
SolveTowers(1, Source, Destination,
Spare) SolveTowers(Count-1, Spare,
Destination, Source)
55
Tower of Hanoi
SolveTowers(3, A, B, C)
SolveTowers(2, A, C, B)
SolveTowers(2, C, B, A)
SolveTowers(1, A, B, C)
SolveTowers(1, A, B, C)
SolveTowers(1, C, A, B)
SolveTowers(1, A, C, B)
SolveTowers(1, C, B, A)
SolveTowers(1, A, B, C)
SolveTowers(1, B, C, A)
The order of recursive calls that results from
SolveTowers(3, A, B, C)
56
Recursion and Efficiency
• The inefficiency of some recursive algorithm

57
Use iterative (Example)
• int interativeRabbit(int n)
• int prev1, curr1, next1
• for (int i 3 i ltn i)
• next prevcurr
• prev curr
• curr next
• return next

58
Summary
• Recursion solves a problem by solving a smaller
problem of the same type
• Four questions
• How can you define the problem in terms of a
smaller problem of the same type?
• How does each recursive call diminish the size of
the problem?
• What instance(s) of the problem can serve as the
base case?
• As the problem size diminishes, will you reach a
base case?

59
Summary
• To construct a recursive solution, assume a
recursive calls postcondition is true if its
precondition is true
• The box trace can be used to trace the actions of
a recursive method
• Recursion can be used to solve problems whose
iterative solutions are difficult to conceptualize

60
Summary
• Some recursive solutions are much less efficient
than a corresponding iterative solution due to
their inherently inefficient algorithms and the