Recursion

1. Recursion Ellen Walker CPSC 201 Data Structures Hiram College

2. Divide & Conquer • To solve a big problem, break it down into smaller problems • Examples: • Find the largest element in a list by comparing pairs of elements • Binary search: find an element in a list by deciding which half of the list it is in, and sorting the smaller half-list

3. Recursion • Every smaller problem (except the smallest one) is an instance of the larger problem • Examples: • Binary Search • Factorial • Fibonacci number • Implementation: function that calls itself

4. Sequential Search as Recursion //Find (the first instance of) element in list • If the list is empty, return “not found” • Else if the first element of the list is the one you’re looking for, return it • Else search in the smaller list starting from the second element of the list

5. Sequential Search in Java //Check if value is in array of integers //Note: end is one value beyond the last in list boolean search1 (int value, int[] list, int st, int end){ if (st==end) return false; // empty list if (list[st]==value) return true; return search1(value, list, st+1, end); }

6. Sequential Search as Divide & Conquer • Divide the problem into two smaller problems: • Is the value the first element of the list? • Find the value in the smaller list starting at the second element. • Disadvantage: each “smaller” problem isn’t very much smaller

7. Binary Search • Is the element in the first or second half of the list? (For a sorted list, this is a single comparison to the middle element) • Search for the element in the appropriate half of the list

8. Binary Search in Java boolean search2(int val, int[] list, int st, int end){ if (st==end) return false; //empty list int middle = (end-st)/2; if (list[middle]==val) return true; if (val < list[middle]) return search2(val,list,st,middle)); else return search2(val, list, middle+1, end); }

9. Binary vs. Sequential • Sequential search: each list search is 1 smaller • Binary search: each list search is half as big • Binary search is faster, but… • Binary search requires a sorted list

10. Aspects of A Recursive Solution • Base case (or basis or degenerate case) • List is empty, List has 1 element • Recursive call • Call to search1 or search2 • Recursive call must be “closer” to the base case • The list is shorter in the recursive call

11. 4 Questions for Recursive Algorithm Design • How can you define the problem in terms of a smaller problem of the same type? • “single step” + “smaller problem” • How does each recursive call diminish the size of the problem? • What instance of the problem can serve as the base case? • As the problem size diminishes, will you reach this base case?

12. 4 Answers for Factorial • How can you define the problem… Fact(N) is N*Fact(N-1) • How does each … call diminish… N-1 is smaller than N • What … can serve as the base case? Fact(0) is 1 • …will you reach the base case? Yes, as long as you start with N≥0 (a precondition)

13. Factorial in Java • Note: this is a “valued” recursive function • The final result is constructed from the results of recursive calls int Fact(int N){ assert (N>=0); //make sure of precondition if (N==0) return 1; else return N*Fact(N-1); }

14. Activation record • Information recorded for each function call • Values of the parameters • Function’s local variables • Space for result • Where to return to (important if multiple calls!) • For each function call, create a new activation record • For each return, erase the activation record

15. Writing a string backward • Base case: • Define the problem in terms of a smaller one? • How does each case diminish…? • Guaranteed to reach the base case?

16. Multiple Calls in One Function • Fibonacci sequence (counting rabbits) • Rabbit(N) = Rabbit(N-1)+Rabbit(N-2) • Rabbit(1) = Rabbit(2) = 1 • (Rabbit is not defined for values < 1)

17. A Counting Problem • How many ways to visit k of n planets? • Pick some planet (p) • There are count(n-1, k) ways to visit k planets without visiting p • There are count(n-1, k-1) ways to visit k planets with visiting p • Therefore: count(n, k) = count(n-1,k)+count(n-1,k-1) • Base case?

18. Impractical Recursions • Fibonacci: makes as many calls as rabbits! • Solution: compute it iteratively (save intermediate steps) • Counting: similar to Fibonacci • Solution: use mathematics to come up with a closed form • Count(n,k) = n! / (k! (n-k)!)

19. Impractical but unavoidable • Towers of Hanoi • Move N disks from one tower to another, never putting a larger disk on a smaller disk • Solution in 3 steps: • Recursively move N-1 disks to the extra tower • Move the Nth disk to the destination tower • Recursively move N-1 disks to the destination tower • Solution time: O(2N)

20. K’th smallest element • Pick a “partition” element & put smaller elements before, and larger elements after • Remember quicksort? • If “partition” element is k’th, it is the answer • Otherwise, recurse over the half that has the k’th element in it (change k if it’s the second half!) • Impossible to predict how long it will take without knowing the exact array!

21. Recursive Linked List • The empty list is a linked list • A list consisting of a head item followed by a list of the rest of the items is a linked list • Method to • Add at the beginning of the list • Add at the end of the list • Recursive method to • Count the elements • See if an element is in the list