Recursion

Chapter 7

Spring 2010 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

Spring 2010 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

Spring 2010 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

Spring 2010 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)

Spring 2010 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

Spring 2010 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

Spring 2010 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

Spring 2010 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

Spring 2010 CS 225 10

Tracing a Recursive Method

Spring 2010 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

Spring 2010 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);}

Spring 2010 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);

Spring 2010 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);

}

Spring 2010 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

Spring 2010 CS 225 16

Iterative Factorial Method

public static factorialIter(

int n) {

int result = 1;

for k=1; k<=n; k++)

result *= n;

return result;

}

Spring 2010 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

Spring 2010 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);

}

Spring 2010 CS 225 19

Efficiency of Recursion: Exponential Fibonacci

Inefficient

Spring 2010 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);}

Spring 2010 CS 225 21

Efficiency of Recursion: O(n) Fibonacci

Efficient

Spring 2010 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

Spring 2010 CS 225 23

Algorithm for Recursive Linear Array Search

Spring 2010 CS 225 24

Implementation of Recursive Linear Search

Spring 2010 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 in which the target cannot be

Spring 2010 CS 225 26

Binary Search Algorithm

Spring 2010 CS 225 27

Trace of a Binary Search

Spring 2010 CS 225 28

Implementation of Binary Search

Spring 2010 CS 225 29

Implementation of Binary Search

Spring 2010 CS 225 30

Efficiency of Binary Search

• At each recursive call we eliminate half the array elements from consideration

• The number of times you can divide N by 2 before getting to 0 is

log2 N

• Therefore the efficiency is O(log2n)

Spring 2010 CS 225 31

Comparable Interface• 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 of a class

Spring 2010 CS 225 32

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

Spring 2010 CS 225 33

Recursive Data Structures• Computer scientists often encounter data structures

that are defined recursively– Trees (Chapter 6) 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

Spring 2010 CS 225 34

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• Recursive definition

– A linked list is either empty, or it consists of a node (called the list head) that stores data and a reference to a linked list

Spring 2010 CS 225 35

Recursive Size Method

Spring 2010 CS 225 36

Recursive toString Method

Spring 2010 CS 225 37

Recursive Replace Method

Spring 2010 CS 225 38

Recursive Add Method

Spring 2010 CS 225 39

Recursive Remove Method

Spring 2010 CS 225 40

Recursive Remove Method

Spring 2010 CS 225 41

Problem Solving with Recursion

• Will look at two problems– Towers of Hanoi– Counting cells in a blob

Spring 2010 CS 225 42

Towers of Hanoi

Spring 2010 CS 225 43

Towers of Hanoi

Spring 2010 CS 225 44

Algorithm for Towers of Hanoi

Spring 2010 CS 225 45

Algorithm for Towers of Hanoi

Spring 2010 CS 225 46

Algorithm for Towers of Hanoi

Spring 2010 CS 225 47

Recursive Algorithm for Towers of Hanoi

Spring 2010 CS 225 48

Implementation of Recursive Towers of Hanoi

Spring 2010 CS 225 49

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

Spring 2010 CS 225 50

Classes for Counting Cells in a Blob

Spring 2010 CS 225 51

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

Spring 2010 CS 225 52

Implementation

Spring 2010 CS 225 53

Implementation

Spring 2010 CS 225 54

Counting Cells in a Blob

Spring 2010 CS 225 55

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

Spring 2010 CS 225 56

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

Spring 2010 CS 225 57

Backtracking

Spring 2010 CS 225 58

Recursive Algorithm for Finding Maze Path

Spring 2010 CS 225 59

Maze Implementation

Spring 2010 CS 225 60

Maze Implementation

Spring 2010 CS 225 61

Maze Implementation

Spring 2010 CS 225 62

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

Spring 2010 CS 225 63

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