Chapter 11
Recursion
Recursive void Methods Recursive void Methods
• A recursive method is a method that includes a call to itself
• Recursion is based on the general problem solving technique of breaking down a task into solving technique of breaking down a task into subtasks
– In particular, recursion can be used whenever one subtask is a smaller version of the original task
Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 11‐2
Vertical Numbers Vertical Numbers
Th t ti i th d it V ti lt k
• The static recursive methodwriteVerticaltakes one (nonnegative) intargument, and writes that intwith the digits going down the screen one per line
– Note: Recursive methods need not be static
• This task may be broken down into the following two subtasks
– Simple case: If n<10, then write the number n to the screenSimple case: If n 10, then write the number n to the screen – Recursive Case: If n>=10, then do two subtasks:
• Output all the digits except the last digit
• Output the last digit
• Output the last digit
Vertical Numbers Vertical Numbers
i h h f h
• Given the argument 1234, the output of the first subtask would be:
1 2 3
• The output of the second part would be: The output of the second part would be:
4
Vertical Numbers Vertical Numbers
• The decomposition of tasks into subtasks can be used to derive the method definition:
– Subtask 1 is a smaller version of the original task, so it can be implemented with a recursive call so it can be implemented with a recursive call – Subtask 2 is just the simple case
Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 11‐5
Algorithm for Vertical Numbers Algorithm for Vertical Numbers
• Given parameter n :
if (n<10)
S t t i tl ( ) System.out.println(n);
else {
writeVertical
(the number n with the last digit removed);
System out println(the last digit of n);
System.out.println(the last digit of n);
}
– Note: n/10is the number nwith the last digit g removed, and n%nis the last digit of n
Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 11‐6
A Recursive void Method (Part 1 of 2)
A Recursive void Method (Part 1 of 2) A Recursive A Recursive void Method (Part 2 of 2) void Method (Part 2 of 2)
Tracing a Recursive Call Tracing a Recursive Call
• Recursive methods are processed in the same way as any method call
writeVertical(123);
When this call is executed the argument 123 is – When this call is executed, the argument 123 is
substituted for the parameter n, and the body of the method is executed
the method is executed
– Since 123 is not less than 10 , the else part is t d
executed
Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 11‐9
Tracing a Recursive Call Tracing a Recursive Call
Th l t b i ith th th d ll
– The else part begins with the method call:
writeVertical(n/10);
– Substituting nequal to 123produces:
writeVertical(123/10);
– Which evaluates to writeVertical(12);
writeVertical(12);
– At this point, the current method computation is placed on hold, and the recursive call writeVertical is executed with the parameter 12
12
– When the recursive call is finished, the execution of the suspended computation will return and continue from the point above
11‐10 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Execution of writeVertical(123)
Execution of writeVertical(123) Tracing a Recursive Call Tracing a Recursive Call
it V ti l(12) writeVertical(12);
– When this call is executed, the argument 12is substituted for the parameter n, and the body of the method is p y executed
– Since 12is not less than 10, the elsepart is executed The else part begins with the method call:
– The else part begins with the method call:
writeVertical(n/10);
– Substituting nequal to 12produces:
writeVertical(12/10);
– Which evaluates to
write Vertical(1);
write Vertical(1);
Tracing a Recursive Call Tracing a Recursive Call
– So this second computation of writeVertical is suspended, leaving two computations waiting to resume , as the computer begins to execute
another recursive call
– When this recursive call is finished, the execution of the second suspended computation will return and continue from the point above
11‐13 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Execution of
writeVertical(12)
11‐14 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Tracing a Recursive Call Tracing a Recursive Call
write Vertical(1);
– When this call is executed, the argument 1is substituted
f th t d th b d f th th d i
for the parameter n, and the body of the method is executed
Since1is less than10 theif-elsestatement Boolean – Since 1is less than 10, the if-elsestatement Boolean
expression is finally true
– The output statement writes the argumentThe output statement writes the argument 11to theto the screen, and the method ends without making another recursive call
– Note that this is the stopping case
Execution of
writeVertical(1)
Tracing a Recursive Call Tracing a Recursive Call
Wh h ll i i l(1) d h
• When the call writeVertical(1) ends, the suspended computation that was waiting for it to end (the one that was initiated by the call
end (the one that was initiated by the call
writeVertical(12)) resumes execution where it left off
it left off
• It outputs the value 12%10 , which is 2
• This ends the method
• This ends the method
• Now the first suspended computation can resume execution
execution
11‐17 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Completion of writeVertical(12) Completion of writeVertical(12)
11‐18 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Tracing a Recursive Call Tracing a Recursive Call
Th fi t d d th d th th t
• The first suspended method was the one that was initiated by the call writeVertical(123)
• It resumes execution where it left off
• It resumes execution where it left off
• It outputs the value 123%10, which is 3
• The execution of the original method call ends
• The execution of the original method call ends
• As a result, the digits 1,2, and 3 have been written to the screen one per line, in that order
the screen one per line, in that order
Completion of writeVertical(123)
Completion of writeVertical(123)
A Closer Look at Recursion A Closer Look at Recursion
• The computer keeps track of recursive calls as follows:
– When a method is called, the computer plugs in the arguments for the parameter(s), and starts executing the
d code
– If it encounters a recursive call, it temporarily stops its computation
computation
– When the recursive call is completed, the computer returns to finish the outer computation
returns to finish the outer computation
11‐21 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Closer Look at Recursion A Closer Look at Recursion
Wh th t t i ll it
• When the computer encounters a recursive call, it must temporarily suspend its execution of a method
– It does this because it must know the result of theIt does this because it must know the result of the recursive call before it can proceed
– It saves all the information it needs to continue the comp tation later on hen it ret rns from the rec rsi e computation later on, when it returns from the recursive call
• Ultimately, this entire process terminates when one y, p of the recursive calls does not depend upon
recursion to return
11‐22 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
General Form of a Recursive Method Definition General Form of a Recursive Method Definition
• The general outline of a successful recursive method definition is as follows:
– One or more cases that include one or more recursive calls to the method being defined
• These recursive calls should solve "smaller" versions of the task performed by the method being defined
– One or more cases that include no recursive calls: baseOne or more cases that include no recursive calls: base cases or stopping cases
Pitfall: Infinite Recursion Pitfall: Infinite Recursion
• In the writeVertical example, the series of recursive calls eventually reached a call of the method that did not involve recursion (a stopping method that did not involve recursion (a stopping case)
• If, instead, every recursive call had produced If, instead, every recursive call had produced another recursive call, then a call to that method would, in theory, run forever
h ll d f
– This is called infinite recursion
– In practice, such a method runs until the computer runs out of resources, and the program terminates runs out of resources, and the program terminates abnormally
Pitfall: Infinite Recursion Pitfall: Infinite Recursion
• An alternative version of writeVertical
– Note: No stopping case!
public static void public static void
newWriteVertical(int n) {
{
newWriteVertical(n/10);
System.out.println(n%10);
System.out.println(n%10);
}
11‐25 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Pitfall: Infinite Recursion Pitfall: Infinite Recursion
• A program with this method will compile and run
• Calling newWriteVertical(12)causes that execution to stop to execute the recursive call newWriteVertical(12/10)
Which is equivalent to W it V ti l(1) – Which is equivalent to newWriteVertical(1)
• Calling newWriteVertical(1)causes that execution to stop to execute the recursive call
to stop to execute the recursive call newWriteVertical(1/10)
– Which is equivalent to newWriteVertical(0)
11‐26 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Pitfall: Infinite Recursion Pitfall: Infinite Recursion
• Calling newWriteVertical(0) causes that execution to stop to execute the recursive call
W it V ti l(0/10) newWriteVertical(0/10)
– Which is equivalent to newWriteVertical(0)
A d f !
– . . . And so on, forever!
• Since the definition of newWriteVertical has no stopping case the process will proceed has no stopping case, the process will proceed forever (or until the computer runs out of resources)
resources)
Stacks for Recursion Stacks for Recursion
T k t k f i ( d th thi ) t
• To keep track of recursion (and other things), most computer systems use a stack
– A stack is a very specialized kind of memory structureA stack is a very specialized kind of memory structure analogous to a stack of paper
– As an analogy, there is also an inexhaustible supply of extra blank sheets of paper
blank sheets of paper
– Information is placed on the stack by writing on one of these sheets, and placing it on top of the stack (becoming the new top of the stack)
– More information is placed on the stack by writing on another one of these sheets placing it on top of the stack another one of these sheets, placing it on top of the stack, and so on
Stacks for Recursion Stacks for Recursion
– To get information out of the stack, the top paper can be read, but only the top paper
T t i f ti th t b th
– To get more information, the top paper can be thrown away, and then the new top paper can be read, and so on
Si th l t h t t th t k i th fi t h t
• Since the last sheet put on the stack is the first sheet taken off the stack, a stack is called a last‐in/first‐out memor str ct re (LIFO)
memory structure (LIFO)
11‐29 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Stacks for Recursion Stacks for Recursion
T k t k f i h th d i
• To keep track of recursion, whenever a method is called, a new "sheet of paper" is taken
– The method definition is copied onto this sheet and theThe method definition is copied onto this sheet, and the arguments are plugged in for the method parameters – The computer starts to execute the method body – When it encounters a recursive call, it stops the
computation in order to make the recursive call
– It writes information about the current method on theIt writes information about the current method on the sheet of paper, and places it on the stack
11‐30 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Stacks for Recursion Stacks for Recursion
h f i d f h i
• A new sheet of paper is used for the recursive call
– The computer writes a second copy of the method, plugs in the arguments, and starts to
b d execute its body
– When this copy gets to a recursive call, its
f d h k l d
information is saved on the stack also, and a new sheet of paper is used for the new recursive call
Stacks for Recursion Stacks for Recursion
Thi i il i ll h h d
• This process continues until some recursive call to the method completes its computation without producing any more recursive calls
– Its sheet of paper is then discarded
• Then the computer goes to the top sheet of paper on the k
stack
– This sheet contains the partially completed computation that is waiting for the recursive computation that just endedg p j
– Now it is possible to proceed with that suspended computation
Stacks for Recursion Stacks for Recursion
Af h d d i d h
• After the suspended computation ends, the
computer discards its corresponding sheet of paper (the one on top)
(the one on top)
• The suspended computation that is below it on the stack now becomes the computation on top of the stack now becomes the computation on top of the stack
• This process continues until the computation on the
• This process continues until the computation on the bottom sheet is completed
11‐33 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Stacks for Recursion Stacks for Recursion
D di h i ll d
• Depending on how many recursive calls are made, and how the method definition is written, the stack may grow and shrink in any fashion
may grow and shrink in any fashion
• The stack of paper analogy has its counterpart in the computer
– The contents of one of the sheets of paper is called a stack frame or activation record
The stack frames don't actually contain a complete copy of – The stack frames don t actually contain a complete copy of
the method definition, but reference a single copy instead
11‐34 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Pitfall: Stack Overflow Pitfall: Stack Overflow
Th i l li it t th i f th t k
• There is always some limit to the size of the stack
– If there is a long chain in which a method makes a call to itself, and that call makes another recursive call, . . . , and itself, and that call makes another recursive call, . . . , and so forth, there will be many suspended computations placed on the stack
If there are too many then the stack will attempt to grow – If there are too many, then the stack will attempt to grow
beyond its limit, resulting in an error condition known as a stack overflow
f k fl f
• A common cause of stack overflow is infinite recursion
Recursion Versus Iteration Recursion Versus Iteration
R i i b l l
• Recursion is not absolutely necessary
– Any task that can be done using recursion can also be done in a nonrecursive manner
in a nonrecursive manner
– A nonrecursive version of a method is called an iterative version
• An iteratively written method will typically use loops of some sort in place of recursion p
• A recursively written method can be simpler, but will
usually run slower and use more storage than an y g
equivalent iterative version
Iterative version of writeVertical Iterative version of writeVertical
11‐37 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Recursive Methods that Return a Value Recursive Methods that Return a Value
R i i t li it d t id th d
• Recursion is not limited to voidmethods
• A recursive method can return a value of any type
• An outline for a successful recursive method that returns a
• An outline for a successful recursive method that returns a value is as follows:
– One or more cases in which the value returned is computed in terms of calls to the same method
– the arguments for the recursive calls should be intuitively "smaller"
– One or more cases in which the value returned is computed withoutOne or more cases in which the value returned is computed without the use of any recursive calls (the base or stopping cases)
11‐38 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Another Powers Method Another Powers Method
Th h d f h M h l
• The method pow from the Math class computes powers
It t k t t f t d bl d t
– It takes two arguments of type doubleand returns a value of type double
• The recursive method power takes two arguments
• The recursive method power takes two arguments of type int and returns a value of type int
– The definition ofThe definition of power is based on the following power is based on the following formula:
xnis equal to xn‐1* x
Another Powers Method Another Powers Method
• In terms of Java, the value returned by
power(x, n) for n>0 should be the same p
as
power(x n-1) * x power(x, n 1) * x
• When n=0, then power(x, n) should return 1
– This is the stopping case pp g
The Recursive Method power (Part 1 of 2)
11‐41 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
The Recursive Method power (Part 1 of 2)
11‐42 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Evaluating the Recursive Method Call
power(2,3) Thinking Recursively Thinking Recursively
• If a problem lends itself to recursion, it is more important to think of it in recursive terms, rather than concentrating on the stack and the suspended computations
power(x,n) returns power(x, n-1) * x
I h f h d h l h
• In the case of methods that return a value, there are
three properties that must be satisfied, as follows:
Thinking Recursively Thinking Recursively
1 Th i i fi i i
1. There is no infinite recursion
– Every chain of recursive calls must reach a stopping case
2 Each stopping case returns the correct value for that case 2. Each stopping case returns the correct value for that case 3. For the cases that involve recursion: if all recursive calls
return the correct value, then the final value returned by the method is the correct value
• These properties follow a technique also known as mathematical induction
mathematical induction
11‐45 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Tail Recursion Tail Recursion
Wh h i h d d hi f h
• When the recursive method does nothing after the recursive call except return the value then the method is called tail recursive
• Tail recursive methods can easily be converted into an equivalent iterative algorithm
– Your compiler may do this automatically for greater efficiency – A similar effect can be achieved if the compiler re‐uses the stack
frame for successive recursive calls
11‐46 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Recursive Design Techniques Recursive Design Techniques
h l b li d i
• The same rules can be applied to a recursive void method:
1. There is no infinite recursion
2. Each stopping case performs the correct action pp g p for that case
3. For each of the cases that involve recursion: if all recursive calls perform their actions correctly, then the entire case performs correctly
Binary Search Binary Search
Bi h i h d h
• Binary search uses a recursive method to search an array to find a specified value
Th b d
• The array must be a sorted array:
a[0]≤a[1]≤a[2]≤. . . ≤ a[finalIndex]
f h l f d d d
• If the value is found, its index is returned
• If the value is not found, ‐1 is returned
• Note: Each execution of the recursive method
reduces the search space by about a half
Binary Search Binary Search
• An algorithm to solve this task looks at the middle of the array or array segment first
• If the value looked for is smaller than the value in the middle of the array
– Then the second half of the array or array segment can be ignored
– This strategy is then applied to the first half of the array or array segment
11‐49 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Binary Search Binary Search
If h l l k d f i l h h l i h iddl f
• If the value looked for is larger than the value in the middle of the array or array segment
– Then the first half of the array or array segment can be ignoredThen the first half of the array or array segment can be ignored – This strategy is then applied to the second half of the array or array
segment
• If the value looked for is at the middle of the array or array
• If the value looked for is at the middle of the array or array segment, then it has been found
• If the entire array (or array segment) has been searched inIf the entire array (or array segment) has been searched in this way without finding the value, then it is not in the array
11‐50 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Pseudocode for Binary Search
Pseudocode for Binary Search Recursive Method for Binary
Search
Execution of the Method search (Part 1 of 2)
11‐53 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Execution of the Method search (Part 1 of 2)
11‐54 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Checking the search Method Checking the search Method
1. There is no infinite recursion
• On each recursive call, the value of , first is increased, or the value of last is decreased
• If the chain of recursive calls does not end in
• If the chain of recursive calls does not end in some other way, then eventually the method will be called with first larger than last will be called with first larger than last
Checking the search Method Checking the search Method
h i f h
2. Each stopping case performs the correct action for that case
• If first > last, there are no array elements between a[first] and a[last] , so key is
h f h d
not in this segment of the array, and result is correctly set to -1
f l
• If key == a[mid], result is correctly set to
mid
Checking the search Method Checking the search Method
3 F h f th th t i l i if ll
3. For each of the cases that involve recursion, if all recursive calls perform their actions correctly, then the entire case performs correctly
the entire case performs correctly
• If key < a[mid], then keymust be one of the elements a[first]through a[mid-1], or it is not in the array
the array
• The method should then search only those elements, which it does
• The recursive call is correct, therefore the entire action is correct
11‐57 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Checking the search Method Checking the search Method
Ifk [ id] th k t b f th
• If key > a[mid], then keymust be one of the elements a[mid+1]through a[last], or it is not in the arrayy
• The method should then search only those elements, which it does
• The recursive call is correct, therefore the entire action is correct
Th th d h ll th t t
The method search passes all three tests:
Therefore, it is a good recursive method definition
11‐58 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Efficiency of Binary Search Efficiency of Binary Search
• The binary search algorithm is extremely fast compared to an algorithm that tries all array p g y elements in order
– About half the array is eliminated from – About half the array is eliminated from
consideration right at the start
Th t f th th i hth f th
– Then a quarter of the array, then an eighth of the array, and so forth
Efficiency of Binary Search Efficiency of Binary Search
Gi i h 1 000 l h bi h ill
• Given an array with 1,000 elements, the binary search will only need to compare about 10 array elements to the key value, as compared to an average of 500 for a serial search , p g algorithm
• The binary search algorithm has a worst‐case running time
h i l i h i O(l )
that is logarithmic: O(log2n)
– A serial search algorithm is linear: O(n)
• If desired the recursive version of the methodIf desired, the recursive version of the method searchsearchcancan be converted to an iterative version that will run more efficiently
Iterative Version of Binary Search (P 1 f 2)
(Part 1 of 2)
11‐61 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Iterative Version of Binary Search (Part 2 of 2)
11‐62 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.