# Recursion - PowerPoint PPT Presentation

PPT – Recursion PowerPoint presentation | free to download - id: 70d1f0-YTQ4M The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
Title:

## Recursion

Description:

### Recursion Chapter 8 – PowerPoint PPT presentation

Number of Views:36
Avg rating:3.0/5.0
Slides: 37
Provided by: SteveA202
Category:
Tags:
Transcript and Presenter's Notes

Title: Recursion

1
Recursion
• Chapter 8

2
Chapter Contents
• What Is Recursion?
• Tracing a Recursive Method
• Recursive Methods That Return a Value
• Recursively Processing an Array
• Recursively Processing a Linked Chain
• The Time Efficiency of Recursive Methods
• Time Efficiency of countDown
• A Simple Solution to a Difficult Problem
• A Poor Solution to a Simple Problem

3
What Is Recursion?
• It is a problem-solving process involves
repetition
• Breaks a problem into identical but smaller
problems
• Eventually you reach a smallest problem
• Answer is obvious or trivial
• Using the solution to smallest problem enables
you to solve the previous smaller problems
• Eventually the original big problem is solved
• An alternative to iteration
• An iterative solution involves loops

4
What Is Recursion?
New Year Eve counting down from 10.
5
What Is Recursion?
• A method that calls itself is a recursive method
• Base case a known case in a recursive
definition. The smallest problem
• Eventually, one of the smaller problems must be
the base case

/ Task Counts down from a given positive
integer. _at_param integer an integer gt 0
/ public static void countDown(int
integer) System.out.println(integer) if
(integer gt 1) countDown(integer - 1) // end
countDown
6
When Designing Recursive Solution
• Four questions to ask before construct recursive
solutions. If you follow these guidelines, you
can be assured that it will work.
• 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 of the problem can serve as the
base case?
• As the problem size diminishes, will you reach
this base case?

7
When Designing Recursive Solution
• For the method countDown, we have the following
• countDown displays the given integer as the part
of the solution that it contribute directly. Then
call countDown with smaller size.
• The smaller problem is counting down from integer
-1.
• The if statement asks if the process has reached
the base case. Here, the base case occurs when
integer is 1.

8
Recursive Solution Guidelines
• Method definition must provide parameter
• Typically includes an if or a switch statement
• One or more of these cases should provide a non
recursive solution( infinite recursion if dont)
• The base or stopping case
• One or more cases includes recursive invocation
• Takes a step towards the base case

9
Tracing a Recursive Method
• Given

public static void countDown(int
integer) System.out.println(integer) if
(integer gt 1) countDown(integer - 1) // end
countDown
The effect of method call countDown(3)
10
Tracing a Recursive Method
Tracing the recursive call countDown(3)
11
Compare Iterative and Recursive Programs
• //Recursive version
• public static void countDown( int integer)
• if ( integer gt 1)
• System.out.println(integer)
• countDown(integer -1)
• //Iterative version
• public static void countDown( int integer)
• while ( integer gt 1)
• System.out.println(integer)
• integer--

12
Question?
• Could you write an recursive method that skips n
lines of output, where n is a positive integer.
Use System.out.println() to skip one line.
• Describe a recursive algorithm that draws a given
number of concentric circles. The innermost or
outmost circle should have a given diameter. The
diameter of each of the other circles should be
three-fourths the diameter of the circle just
outside it.

13
• pubic static void skipLines ( int givenNumber)
• if (givenNumber gt 1)
• System.out.println()
• skipLines(givenNumber 1)
• drawConcentricCircle( givenNumber, givenDiameter)
• // what should be put inside??.

14
Tracing a Recursive Method
• Each call to a method generate an activation
record that captures the state of the methods
execution and that is placed into a ADT stack.
• The activation-record stack remembers the history
of incompleted method calls. A snapshot of a
methods state.
• The topmost activation record holds the data
values for the currently executing method.
• When topmost method finishes, its activation
record is popped
• In this way, Java can suspend the execution of a
recursive method and re-invoke it when it appears
on the top.

15
Tracing a Recursive Method
The stack of activation records during the
execution of a call to countDown(3) continued ?
16
Tracing a Recursive Method
Note the recursive method will use more memory
than an iterative method due to the stack of
activation records
ctd. The stack of activation records during the
execution of a call to countDown(3)
17
Tracing a Recursive Method
• Too many recursive calls can cause the error
message stack overflow. Stack of activation
records has become full. Method has used too much
memory.
• Infinite recursion or large-size problems are the
likely cause of this error.

18
Recursive Methods That Return a Value
• Task Compute the sum1 2 3 n for an
integer n gt 0

public static int sumOf(int n) int sum if (n
1) sum 1 // base case else sum
sumOf(n - 1) n // recursive call return
sum // end sumOf
19
Recursive Methods That Return a Value
The stack of activation records during the
execution of a call to sumOf(3)
20
Recursively Processing an Array
• When processing array recursively, divide it into
two pieces
• Last element one piece, rest of array another
• First element one piece, rest of array another
• Divide array into two halves
• A recursive method part of an implementation of
• Its necessary parameters make it unsuitable as an

21
• To write a method that processes a chain of
• Use a reference to the chain's first node as the
method's parameter
• Then process the first node
• Followed by the rest of the chain

public void display() displayChain(firstNode)
System.out.println() // end display private
void displayChain(Node nodeOne) if (nodeOne !
null) System.out.print(nodeOne.data "
") displayChain(nodeOne.next) // end
displayChain
22
Recursively Divide the Array in Half
• public static void displayArray( int array, int
first, int last)
• if (first last)
• System.out.print(arrayfirst)
• else
• int mid (first last) /2
• displayArray(array, first, mid)
• displayArray(array, mid1, last)

23
A Simple Solution to a Difficult Problem
The initial configuration of the Towers of Hanoi
for three disks
24
A Simple Solution to a Difficult Problem
• Rules for the Towers of Hanoi game
• Move one disk at a time. Each disk you move must
be a topmost disk.
• No disk may rest on top of a disk smaller than
itself.
• You can store disks on the second pole
temporarily, as long as you observe the previous
two rules.

25
A Simple Solution to a Difficult Problem
The sequence of moves for solving the Towers of
Hanoi problem with three disks. Continued ?
26
A Simple Solution to a Difficult Problem
(ctd) The sequence of moves for solving the
Towers of Hanoi problem with three disks
27
A Simple Solution to a Difficult Problem
The smaller problems in a recursive solution for
four disks
28
A Simple Solution to a Difficult Problem
• Algorithm for solution with 1 disk as the base
case

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)
29
Recursion Efficiency
• How many moves occur for n disks?
• m(1) 1 for ngt1, two recursive calls to solve
problems that have n-1 disks.
• m(n) m(n-1) m(n-1) 1 2m(n-1) 1
• Lets evaluate the recurrence for m(n) for a few
values of n
• m(1) 1 m(2) 3 m(3) 7m(4) 15 m(5) 31
m(6) 63.
• m(n) 2n -1

30
Mathematical Induction
• Prove this conjecture m(n) 2n -1 by using
mathematical induction
• We know that m(1) 1, which equals to 21-11, so
the conjecture is true for n 1.
• Now assume that it is true for n1,2,,k, and
consider m(k1).
• m(k1) 2m(k) 1 (use the recurrence relation)
• 2(2k-1) 1 2(k1) -1 ( we assume that m(k)
2k-1)
• Since the conjecture is true for nk1, it is
true for all ngt1

31
Mathematical Induction
• Assume you want to prove some statement P, P(n)
is true for all n starting with n 1. The
Principle of Math Induction states that, to this
end, one should accomplish just two steps
• 1). Prove that P(1) is true.
• 2). Assume that P(k) is true for some k. Derive
from here that P(k1) is also true.
• look P(1) is true and implies P(2). Therefore
P(2) is true. But P(2) implies P(3). Therefore
P(3) is true which implies P(4) and so on.

32
Multiplying Rabbits (The Fibonacci Sequence)
• Rabbits never die
• A rabbit reaches sexual maturity exactly two
months after birth, that is, at the beginning of
its third month of life
• Rabbits are always born in male-female pairs
• At the beginning of every month, each sexually
mature male-female pair gives birth to exactly
one male-female pair

33
Multiplying Rabbits (The Fibonacci Sequence)
• Problem
• How many pairs of rabbits are alive in month n?
• Month Month No calculation rabbit couples
• January 1 1 0 1
• February 2 1 0 1
• March 3 1 1 2
• April 4 2 1 3
• May 5 3 2 5
• June 6 5 3 8
• July 7 8 5 13
• August 8 13 8 21
• Recurrence relation
• rabbit(n) rabbit(n-1) rabbit(n-2)

34
A Poor Solution to a Simple Problem
• Fibonacci numbers
• First two numbers of sequence are 1 and 1
• Successive numbers are the sum of the previous
two
• 1, 1, 2, 3, 5, 8, 13,
• This has a natural looking recursive solution
• Turns out to be a poor (inefficient) solution

35
A Poor Solution to a Simple Problem
• The recursive algorithm

Algorithm Fibonacci(n) if (n lt 1) return
1 else return Fibonacci(n-1) Fibonacci(n-2)
36
A Poor Solution to a Simple Problem
Time efficiency grows exponentially with n, which
is kn
int fib(int n) int fn1 f1 f2
1 for (int i 3 i lt n i) fi
fi-1 fi-2 return fn
Iterative solution is O(n)
The computation of the Fibonacci number F6 (a)
recursively (b) iteratively