Fall 2007CS 2251 Recursion Chapter 7. Fall 2007CS 2252 Chapter Objectives To understand how to think...
-
date post
20-Dec-2015 -
Category
Documents
-
view
216 -
download
0
Transcript of Fall 2007CS 2251 Recursion Chapter 7. Fall 2007CS 2252 Chapter Objectives To understand how to think...
Fall 2007 CS 225 1
Recursion
Chapter 7
Fall 2007 CS 225 2
Chapter Objectives• To understand how to think recursively• To learn how to trace a recursive method• To learn how to write recursive algorithms
and methods for searching arrays• To learn about recursive data structures and
recursive methods for a LinkedList class• To understand how to use recursion to
– solve the Towers of Hanoi problem– to process two-dimensional images– to solve search problems such as finding a path
through a maze using backtracking
Fall 2007 CS 225 3
Recursive Thinking
• Recursion is a problem-solving approach that can be used to generate simple solutions to certain kinds of problems that would be difficult to solve in other ways– Recursion provides a different way of
thinking about a problem
• Recursion splits a problem into one or more simpler versions of itself
Fall 2007 CS 225 4
Recursive Thinking
If there is one figure in the nestprocess the figure
elseprocess the outer figureprocess the nest inside the outer figure
Fall 2007 CS 225 5
When to Use a Recursive Algorithm
• There must be at least one case (the base case), for a small value of n, that can be solved directly
• A problem of a given size n can be split into one or more smaller versions of the same problem (recursive case)
Fall 2007 CS 225 6
Designing a Recursive Algorithm
• Recognize the base case and provide a solution to it
• Devise a strategy to split the problem into smaller versions of itself while making progress toward the base case
• Combine the solutions of the smaller problems in such a way as to solve the larger problem
Fall 2007 CS 225 7
String Length Algorithm
if the string is empty
the length is 0
else
length = 1 plus length of substring that excludes the first character
Fall 2007 CS 225 8
Proof by induction
• Prove the theorem is true for the base case
• Show that if the theorem is assumed true for n, then it must be true for n+1
• See the slides on induction
Fall 2007 CS 225 9
Proving that a Recursive Method is Correct
• Recursive proof is similar to induction– Verify the base case is recognized and
solved correctly– Verify that each recursive case makes
progress towards the base case– Verify that if all smaller problems are
solved correctly, then the original problem is also solved correctly
Fall 2007 CS 225 10
Tracing a Recursive Method
Fall 2007 CS 225 11
Recursive Definitions of Mathematical Formulas
• Mathematicians often use recursive definitions of formulas that lead very naturally to recursive algorithms
• Examples include:– Factorial– Powers– Greatest common divisor
• If a recursive function never reaches its base case, a stack overflow error occurs
Fall 2007 CS 225 12
Recursive Factorial Method
• Recursive definitionn! = 1 if n=0 n * (n - 1)! if n>0
• Methodpublic static int factorial( int n) { if (n==0) return 1; else return n * factorial( n-1);}
Fall 2007 CS 225 13
Recursive Algorithm for xn
• Algorithmif n is 0 result is 1else result is x * xn-1
• Methodpublic static double power( double x, int n) { if (n==0) return 1; else return x * power( x, n-1);
Fall 2007 CS 225 14
Greatest Common Divisor• Euclid's algorithm (assumes m>=n)
gcd(m, n) = n if n is a divisor of m
gcd(m, n) = gcd( n, m % n) otherwise
• Methodpublic static double gcd( int m, int n) {
if (m%n==0)
return n;
else if (m<n);
return gcd( n, m);
else
return gcd( n, m%n);
}
Fall 2007 CS 225 15
Recursion Versus Iteration• There are similarities between recursion and iteration• In iteration, a loop repetition condition determines
whether to repeat the loop body or exit from the loop• In recursion, the condition usually tests for a base
case • You can always write an iterative solution to a
problem that is solvable by recursion• Recursive code may be simpler than an iterative
algorithm and thus easier to write, read, and debug• Iteration is usually more efficient
Fall 2007 CS 225 16
Iterative Factorial Method
public static factorialIter(
int n) {
int result = 1;
for k=1; k<=n; k++)
result *= n;
return result;
}
Fall 2007 CS 225 17
Efficiency of Recursion
• Recursive methods often have slower execution times when compared to their iterative counterparts
• The overhead for loop repetition is smaller than the overhead for a method call and return
• If it is easier to conceptualize an algorithm using recursion, then you should code it as a recursive method– The reduction in efficiency does not outweigh the
advantage of readable code that is easy to debug
Fall 2007 CS 225 18
Recursive Fibonacci Method
• Recursive definitionfibn = 1 for n = 1,2
fibn-1 + fibn-2 for n>2
• Methodpublic static int fibonacci( int n) { if (n<=2) return 1; else return fibonacci(n-1) + fibonacci(n-2);
}
Fall 2007 CS 225 19
Efficiency of Recursion: Exponential Fibonacci
Inefficient
Fall 2007 CS 225 20
An O(n) Recursive Fibonacci Method
• To avoid excessive computation, remember the previous two values.
• Start the computationpublic static int fibonacciStart( int n) { return fibo( 1, 0, n); }
• Recursive method private static int fibo( int current, int previous, int n) if (n==1) return current; else return fibo( current + previous, current, n-1);
}
Fall 2007 CS 225 21
Efficiency of Recursion: O(n) Fibonacci
Efficient
Fall 2007 CS 225 22
Recursive Array Search
• Searching an array can be accomplished using recursion
• Simplest way to search is a linear search– Examine one element at a time starting with the first element
and ending with the last
• Base case for recursive search is an empty array– Result is negative one
• Another base case would be when the array element being examined matches the target
• Recursive step is to search the rest of the array, excluding the element just examined
Fall 2007 CS 225 23
Algorithm for Recursive Linear Array Search
Fall 2007 CS 225 24
Implementation of Recursive Linear Search
Fall 2007 CS 225 25
Design of Binary Search Algorithm
• Binary search can be performed only on an array that has been sorted
• Stop cases– The array is empty– Element being examined matches the target
• Checks the middle element for a match with the target
• Throw away the half of the array that the target cannot lie within
Fall 2007 CS 225 26
Binary Search Algorithm
Fall 2007 CS 225 27
Trace of a Binary Search
Fall 2007 CS 225 28
Implementation of Binary Search
Fall 2007 CS 225 29
Implementation of Binary Search
Fall 2007 CS 225 30
Efficiency of Binary Search and the Comparable Interface
• At each recursive call we eliminate half the array elements from consideration– O(log2n)
• Classes that implement the Comparable interface must define a compareTo method that enables its objects to be compared in a standard way– CompareTo allows one to define the ordering of
elements for their own classes
Fall 2007 CS 225 31
Method Arrays.binarySearch
• Java API class Arrays contains a binarySearch method– Can be called with sorted arrays of primitive types
or with sorted arrays of objects– If the objects in the array are not mutually
comparable or if the array is not sorted, the results are undefined
– If there are multiple copies of the target value in the array, there is no guarantee which one will be found
– Throws ClassCastException if the target is not comparable to the array elements
Fall 2007 CS 225 32
Recursive Data Structures
• Computer scientists often encounter data structures that are defined recursively– Trees (Chapter 8) are defined recursively
• Linked list can be described as a recursive data structure
• Recursive methods provide a very natural mechanism for processing recursive data structures
• The first language developed for artificial intelligence research was a recursive language called LISP
Fall 2007 CS 225 33
Recursive Definition of a Linked List
• A non-empty linked list is a collection of nodes such that each node references another linked list consisting of the nodes that follow it in the list
• The last node references an empty list• A linked list is empty, or it contains a
node, called the list head, that stores data and a reference to a linked list
Fall 2007 CS 225 34
Recursive Size Method
Fall 2007 CS 225 35
Recursive toString Method
Fall 2007 CS 225 36
Recursive Replace Method
Fall 2007 CS 225 37
Recursive Add Method
Fall 2007 CS 225 38
Recursive Remove Method
Fall 2007 CS 225 39
Recursive Remove Method (continued)
Fall 2007 CS 225 40
Problem Solving with Recursion
• Will look at two problems– Towers of Hanoi– Counting cells in a blob
Fall 2007 CS 225 41
Towers of Hanoi
Fall 2007 CS 225 42
Towers of Hanoi (continued)
Fall 2007 CS 225 43
Algorithm for Towers of Hanoi
Fall 2007 CS 225 44
Algorithm for Towers of Hanoi (continued)
Fall 2007 CS 225 45
Algorithm for Towers of Hanoi (continued)
Fall 2007 CS 225 46
Recursive Algorithm for Towers of Hanoi
Fall 2007 CS 225 47
Implementation of Recursive Towers of Hanoi
Fall 2007 CS 225 48
Counting Cells in a Blob
• Consider how we might process an image that is presented as a two-dimensional array of color values
• Information in the image may come from– X-Ray– MRI– Satellite imagery– Etc.
• Goal is to determine the size of any area in the image that is considered abnormal because of its color values
Fall 2007 CS 225 49
Classes for Counting Cells in a Blob
Fall 2007 CS 225 50
Algorithm for Counting Cells in a Blob
if the cell is outside the grid result is 0if color is not abnormal result is 0else
set color to marker color result = 1 + number of cells in blob that includes a neighbor
Fall 2007 CS 225 51
Implementation
Fall 2007 CS 225 52
Implementation
Fall 2007 CS 225 53
Counting Cells in a Blob
Fall 2007 CS 225 54
Backtracking
• Backtracking is an approach to using trial and error in a search for a solution– Backtracking is a systematic approach to trying
alternative paths and eliminating them if they don’t work
• For example: finding a path through a maze– Start by walking down a path as far as you can go
• Eventually, you will reach your destination or you won’t be able to go any farther
• If you can’t go any farther, you will need to retrace your steps
• You need a way to keep track of what you've already tried
Fall 2007 CS 225 55
Backtracking
• Never try the exact same path more than once, and you will eventually find a solution path if one exists
• Problems that are solved by backtracking can be described as a set of choices made by some method
• Recursion allows us to implement backtracking in a relatively straightforward manner– Each activation frame is used to remember the
choice that was made at that particular decision point
• A program that plays chess may involve some kind of backtracking algorithm
Fall 2007 CS 225 56
Backtracking
Fall 2007 CS 225 57
Recursive Algorithm for Finding Maze Path
Fall 2007 CS 225 58
Maze Implementation
Fall 2007 CS 225 59
Maze Implementation
Fall 2007 CS 225 60
Maze Implementation
Fall 2007 CS 225 61
Chapter Review
• A recursive method has a standard form• To prove that a recursive algorithm is correct, you
must– Verify that the base case is recognized and solved
correctly– Verify that each recursive case makes progress toward
the base case– Verify that if all smaller problems are solved correctly,
then the original problem must also be solved correctly
• The run-time stack uses activation frames to keep track of argument values and return points during recursive method calls
Fall 2007 CS 225 62
Chapter Review
• Mathematical Sequences and formulas that are defined recursively can be implemented naturally as recursive methods
• Recursive data structures are data structures that have a component that is the same data structure
• Towers of Hanoi and counting cells in a blob can both be solved with recursion
• Backtracking is a technique that enables you to write programs that can be used to explore different alternative paths in a search for a solution