1. Recursion Chapter 7

2. Spring 2010CS 2252 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

3. Spring 2010CS 2253 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

4. Spring 2010CS 2254 Recursive Thinking If there is one figure in the nest process the figure else process the outer figure process the nest inside the outer figure

5. Spring 2010CS 2255 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)

6. Spring 2010CS 2256 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

7. Spring 2010CS 2257 String Length Algorithm if the string is empty the length is 0 else length = 1 plus length of substring that excludes the first character

8. Spring 2010CS 2258 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

9. Spring 2010CS 2259 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

10. Spring 2010CS 22510 Tracing a Recursive Method

11. Spring 2010CS 22511 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

12. Spring 2010CS 22512 Recursive Factorial Method Recursive definition n! = 1 if n=0 n * (n - 1)! if n>0 Method public static int factorial( int n) { if (n==0) return 1; else return n * factorial( n-1); }

13. Spring 2010CS 22513 Recursive Algorithm for x n Algorithm if n is 0 result is 1 else result is x * x n-1 Method public static double power( double x, int n) { if (n==0) return 1; else return x * power( x, n-1);

14. Spring 2010CS 22514 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 Method public 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); }

15. Spring 2010CS 22515 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

16. Spring 2010CS 22516 Iterative Factorial Method public static factorialIter( int n) { int result = 1; for k=1; k<=n; k++) result *= n; return result; }

17. Spring 2010CS 22517 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

18. Spring 2010CS 22518 Recursive Fibonacci Method Recursive definition fib n = 1 for n = 1,2 fib n-1 + fib n-2 for n>2 Method public static int fibonacci( int n) { if (n<=2) return 1; else return fibonacci(n-1) + fibonacci(n-2); }

19. Spring 2010CS 22519 Efficiency of Recursion: Exponential Fibonacci Inefficient

20. Spring 2010CS 22520 An O(n) Recursive Fibonacci Method To avoid excessive computation, remember the previous two values. Start the computation public 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); }

21. Spring 2010CS 22521 Efficiency of Recursion: O(n) Fibonacci Efficient

22. Spring 2010CS 22522 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

23. Spring 2010CS 22523 Algorithm for Recursive Linear Array Search

24. Spring 2010CS 22524 Implementation of Recursive Linear Search

25. Spring 2010CS 22525 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

26. Spring 2010CS 22526 Binary Search Algorithm

27. Spring 2010CS 22527 Trace of a Binary Search

28. Spring 2010CS 22528 Implementation of Binary Search

29. Spring 2010CS 22529 Implementation of Binary Search

30. Spring 2010CS 22530 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 log 2 N Therefore the efficiency is O(log 2 n)

31. Spring 2010CS 22531 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

32. Spring 2010CS 22532 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

33. Spring 2010CS 22533 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

34. Spring 2010CS 22534 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

35. Spring 2010CS 22535 Recursive Size Method

36. Spring 2010CS 22536 Recursive toString Method

37. Spring 2010CS 22537 Recursive Replace Method

38. Spring 2010CS 22538 Recursive Add Method

39. Spring 2010CS 22539 Recursive Remove Method

40. Spring 2010CS 22540 Recursive Remove Method

41. Spring 2010CS 22541 Problem Solving with Recursion Will look at two problems –Towers of Hanoi –Counting cells in a blob

42. Spring 2010CS 22542 Towers of Hanoi

43. Spring 2010CS 22543 Towers of Hanoi

44. Spring 2010CS 22544 Algorithm for Towers of Hanoi

45. Spring 2010CS 22545 Algorithm for Towers of Hanoi

46. Spring 2010CS 22546 Algorithm for Towers of Hanoi

47. Spring 2010CS 22547 Recursive Algorithm for Towers of Hanoi

48. Spring 2010CS 22548 Implementation of Recursive Towers of Hanoi

49. Spring 2010CS 22549 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

50. Spring 2010CS 22550 Classes for Counting Cells in a Blob

51. Spring 2010CS 22551 Algorithm for Counting Cells in a Blob if the cell is outside the grid result is 0 if color is not abnormal result is 0 else set color to marker color result = 1 + number of cells in blob that includes a neighbor

52. Spring 2010CS 22552 Implementation

53. Spring 2010CS 22553 Implementation

54. Spring 2010CS 22554 Counting Cells in a Blob

55. Spring 2010CS 22555 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

56. Spring 2010CS 22556 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

57. Spring 2010CS 22557 Backtracking

58. Spring 2010CS 22558 Recursive Algorithm for Finding Maze Path

59. Spring 2010CS 22559 Maze Implementation

60. Spring 2010CS 22560 Maze Implementation

61. Spring 2010CS 22561 Maze Implementation

62. Spring 2010CS 22562 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

63. Spring 2010CS 22563 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