1. Chapter 111 Recursion Chapter 11

2. 2 Objectives become familiar with the idea of recursion learn to use recursion as a programming tool become familiar with the binary search algorithm as an example of recursion become familiar with the merge sort algorithm as an example of recursion

3. Chapter 113 Outline The Basics of Recursion Programming with Recursion

4. Chapter 114 The Basics of Recursion: Outline Introduction to Recursion How Recursion Works Recursion versus Iteration Recursive Methods That Return a Value

5. Chapter 115 Introduction to Recursion Sometimes it is possible and useful to define a method in terms of itself. A Java method definition is recursive if it contains an invocation of itself. The method continues to call itself, with ever simpler cases, until a base case is reached which can be resolved without any subsequent recursive calls.

6. Chapter 116 Example: Search for a Name in a Phone Book Open the phone book to the middle. If the name is on this page, you’re done. If the name alphabetically precedes the names on this page, use the same approach to search for the name in the first half of the phone book. Otherwise, use the same approach to search for the name in the second half of the phone book.

7. Chapter 117 Case Study: Digits to Words Write a definition that accepts a single integer and produces words representing its digits. example –input: 223 –output: two two three recursive algorithm –output all but the last digit as words –output the word for the last digit

8. Chapter 118 Case Study: Digits to Words, cont. class RecursionDemo

9. Chapter 119 Case Study: Digits to Words, cont. class RecursionDemo, contd.

10. Chapter 1110 Case Study: Digits to Words, cont.

11. Chapter 1111 How Recursion Works Nothing special is required to handle a call to a recursive method, whether the call to the method is from outside the method or from within the method. At each call, the needed arguments are provided, and the code is executed. When the method completes, control returns to the instruction following the call to the method.

12. Chapter 1112 How Recursion Works, cont. Consider several methods m1, m2, …, mn, with method m1 calling method m2, method m2 calling method m3,…, calling method mn. –When each method completes, control returns to the instruction following the call to the method. In recursion, methods m1, m2, …, mn can all (or some) be the same method, but each call results in a distinct execution of the method.

13. Chapter 1113 How Recursion Works, cont. As always, method m1 cannot complete execution until method m2 completes execution, method m2 cannot complete execution until method m3 completes execution, … until method mn completes execution. If method mn represents a stopping case, it can complete execution, …, then method m2 can complete execution, then method m1 can complete execution.

14. Chapter 1114 How Recursion Works, cont.

15. Chapter 1115 Recursion Guidelines The definition of a recursive method typically includes an if-else statement. –One branch represents a base case which can be solved directly (without recursion). –Another branch includes a recursive call to the method, but with a “simpler” or “smaller” set of arguments. Ultimately, a base case must be reached.

16. Chapter 1116 Infinite Recursion If the recursive invocation inside the method does not use a “simpler” or “smaller” parameter, a base case may never be reached. Such a method continues to call itself forever (or at least until the resources of the computer are exhausted as a consequence of stack overflow). This is called infinite recursion.

17. Chapter 1117 Infinite Recursion, cont. example (with the stopping case omitted) inWords(987);... public static void inWords(int number) { inWords(number/10); System.out.print(digitWord(number%10) + “ “); }

18. Chapter 1118 Recursion vs. Iteration Any recursive method can be rewritten without using recursion (but in some cases this may be very complicated). Typically, a loop is used in place of the recursion. The resulting method is referred to as the iterative version.

19. Chapter 1119 Recursion vs. Iteration, contd. class IterativeDemo

20. Chapter 1120 Recursion vs. Iteration, cont. A recursive version of a method typically executes less efficiently than the corresponding iterative version. This is because the computer must keep track of the recursive calls and the suspended computations. However, it can be much easier to write a recursive method than it is to write a corresponding iterative method.

21. Chapter 1121 Recursive Methods That Return a Value A recursive method can be a void method or it can return a value. At least one branch inside the recursive method can compute and return a value by making a chain of recursive calls. Consider, for example, a method that takes a single int argument and returns the number of zeros in the argument.

22. Chapter 1122 Recursive Methods That Return a Value, cont. If n is two or more digits long, then the number of zero digits in n is (the number of zeros in n with the last digit removed) plus an additional one if the last digit is a zero.

23. Chapter 1123 Recursive Methods That Return a Value, cont. class RecursionDemo2

24. Chapter 1124 Recursive Methods That Return a Value, cont.

25. Chapter 1125 Recursive Methods That Return a Value, cont. What is the value of each of the following expressions? numberOfZeros(20030) numberOfZeros(20031) numberOfZeros(0) numberOfZeros(5) numberOfZeros(50)

26. Chapter 1126 Overloading is Not Recursion If a method name is overloaded and one method calls another method with the same name but with a different parameter list, this is not recursion. Of course, if a method name is overloaded and the method calls itself, this is recursion. Overloading and recursion are neither synonymous nor mutually exclusive.

27. Chapter 1127 Programming with Recursion: Outline Counting Down Binary Search Merge Sort

28. Chapter 1128 Counting Down In this example, method getCount requests a positive number and then counts down to zero. If a nonpositive number is entered, method getCount calls itself recursively.

29. Chapter 1129 Counting Down, cont. class CountDown

30. Chapter 1130 Counting Down, cont.

31. Chapter 1131 Case Study: Binary Search We will design a recursive method that determines if a given number is or is not in a sorted array. –If the number is in the array, the method will return the position of the given number in the array, or -1 if the given number is not in the array. Instead of searching the array linearly, we will search recursively for the given number.

32. Chapter 1132 Binary Search, cont. Because the array is sorted, we can rule out whole sections of the array as we search. –For example, if we are looking for a 7 and we encounter a location containing a 9, we can eliminate from consideration the location containing the 9 and all subsequent locations in the array.

33. Chapter 1133 Binary Search, cont. –Similarly, if we are looking for a 7 and we encounter a location containing a 3, we can eliminate from consideration the location containing the 3 and all preceding locations in the array. – And of course, if we are looking for a 7 and we encounter a location containing a 7, we can terminate our search, just as we could when searching an array linearly.

34. Chapter 1134 Binary Search, cont. We can begin our search by examining an element mid in the middle of the array. pseudocode, first draft: mid = (0 + a.length-1)/2 if (target == a[mid]) return mid; else if (target < a[mid] search a[0] through a[mid-1] else search a[mid + 1] through a[a.length - 1]

35. Chapter 1135 Binary Search, cont. pseudocode, generalized for recursive calls: mid = (first + last)/2 if (target == a[mid]) return mid; else if (target < a[mid] search a[first] through a[mid-1] else search a[mid + 1] through a[last]

36. Chapter 1136 Binary Search, cont. But what if the number is not in the array? –first eventually becomes larger than last and we can terminate the search. Our pseudocode needs to be amended to test if first has become larger than last.

37. Chapter 1137 Binary Search, cont. mid = (first + last)/2 if (first > last) return -1; else if (target == a[mid]) return mid; else if (target < a[mid] search a[first] through a[mid-1] else search a[mid + 1] through a[last]

38. Chapter 1138 Binary Search, cont. class ArraySearcher

39. Chapter 1139 Binary Search, cont.

40. Chapter 1140 Binary Search, cont. class ArraySearcherDemo

41. Chapter 1141 Binary Search, cont.

42. Chapter 1142 Binary Search, cont. With each recursion, the binary search eliminates about half of the array under consideration from further consideration. The number of recursions required either to find an element or to determine that the item is not present is log n for an array of n elements. Thus, for an array of 1024 elements, only 10 recursions are needed.

43. Chapter 1143 Merge Sort Efficient sorting algorithms often are stated recursively. One such sort, merge sort, can be used to sort an array of items. Merge sort takes a “divide and conquer” approach. –The array is divided in halves and the halves are sorted recursively. –Sorted subarrays are merged to form a larger sorted array.

44. Chapter 1144 Merge Sort, cont. pseudocode If the array has only one element, stop. Otherwise Copy the first half of the elements into an array named front. Copy the second half of the elements into an array named back. Sort array front recursively. Sort array tail recursively. Merge arrays front and tail.

45. Chapter 1145 Merging Sorted Arrays The smallest element in array front is front[0]. The smallest element in array tail is tail[0]. The smallest element will be either front[0] or tail [0]. Once that element is removed from either array front or array tail, the smallest remaining element once again will be at the beginning of array front or array tail.

46. Chapter 1146 Merging Sorted Arrays, cont. Generalizing, two sorted arrays can be merged by selectively removing the smaller of the elements from the beginning of (the remainders) of the two arrays and placing it in the next available position in a larger “collector” array. When one of the two arrays becomes empty, the remainder of the other array is copied into the “collector” array.

47. Chapter 1147 Merging Sorted Arrays, cont. int frontIndex = 0, tailIndex = 0, aIndex = 0; while ((frontIndex < front.length) && (tailIndex < tail.length)) { if(front[frontIndex] < tail[tailIndex]} { a[aIndex] = front[frontIndex]; aIndex++; frontIndex++; }

48. Chapter 1148 Merging Sorted Arrays, cont. else { a[aIndex] = tail[tailIndex]; aIndex++; tailIndex++ }

49. Chapter 1149 Merging Sorted Arrays, cont. Typically, when either array front or array tail becomes empty, the other array will have remaining elements which need to be copied into array a. Fortunately, these elements are sorted and are larger than any elements already in array a.

50. Chapter 1150 Merge Sort, cont. class MergeSort

51. Chapter 1151 Merge Sort, cont. class MergeSort, contd.

52. Chapter 1152 Merge Sort, cont. class MergeSortDemo

53. Chapter 1153 Merge Sort, cont.

54. Chapter 1154 Merge Sort, cont. The merge sort algorithm is much more efficient than the selection sort algorithm considered previously.

55. Chapter 1155 Summary You have become familiar with the idea of recursion. You have learned to use recursion as a programming tool. You have become familiar with the binary search algorithm as an example of recursion. You have become familiar with the merge sort algorithm as an example of recursion.