What is Recursion? ! Each problem is a smaller instance of itself. ! Implemented via functions. ! Very powerful solving technique.

Size: px

Start display at page:

Download "What is Recursion? ! Each problem is a smaller instance of itself. ! Implemented via functions. ! Very powerful solving technique."

Rodger Flowers
6 years ago
Views:

1 Recursion 1

2 What is Recursion? Solution given in terms of problem. Huh? Each problem is a smaller instance of itself. Implemented via functions. Very powerful solving technique.

3 Base Case and Recursive Step Base case the point where the solution is known or obvious Recursive Step Expressing the problem as a smaller instance of itself How you get to the base case

4 Binary Search word: brave adictionary: A - Z open adictionary in the middle A - M search the left half: A - M A - G search the left half: A - G A - D Recursive step search the left half: A - D A - B B search the left half: A - B search the right half: B Base Case

5 Binary Search search(in adictionary:dictionary, in word: string) if (adictionary is one page in size) Scan the page for the word else { Open adictionary to a point near the middle Determine which half of adictionary contains the word if (word is in the first half of adictionary) search(first half of adictionary, word) else search(second half of adictionary, word) Base case: Assume we know how to scan a page for a word. Recursive step: Note how in each instance we are solving a smaller version of the original problem.

6 Four Questions 1. How can you define the problem in terms of a smaller problem of the same type? 2. How does each recursive call diminish the size of the problem? 3. What instance of the problem can serve as the base case? 4. As the problem size diminishes, will you reach the base case?

7 Factorial factorial(n) = n.(n-1).(n-2)...1 n > 0 factorial(0) = 1 observe that factorial(n-1) = (n-1).(n-2)...1 so factorial(n) = n.factorial(n-1) The solution to factorial(n) is now given in terms of factorial(n-1), a similar problem, but smaller.

8 Code: Factorial double Factorial(const int n) { // base case if (n == 0) { return (1); else { // recursive step return ( n * Factorial(n - 1) );

9 Factorial Traced 1.Label each recursive step with a label, such as A, B,,,Z 2.Keep a record of the current value of the function's arguments. 3.Keep a record of any local variable within the function.

10 Factorial Traced if (n == 0) return (1); else return ( n * factorial(n - 1) ); // A factorial(5) : n = 5 return (5 * factorial(4): A factorial(4) : n = 4 return (4 * factorial(3): A factorial(3) : n = 3 return (3 * factorial(2): A factorial(2) : n = 2 return (2 * factorial(1): A factorial(1) : n = 1 return (1 * factorial(0): A factorial(5) : n = 5 return (5 * 24) factorial(4) : n = 4 return (4 * 6) : A factorial(3) : n = 3 return (3 * 2): A factorial(2) : n = 2 return (2 * 1): A factorial(1) : n = 1 return (1 * 1): A factorial(0) : n = 0 return (1): A

11 Reverse String Display H E L L O H E L L O First character first rev(ello) H H E L L O Last character first o rev(hell) O L L E H O L L E H

12 First Character First reverse(in s:string) if (string is empty) do nothing else { reverse(s minus the first character) display first character in the string String Output cat at t "" t ta tac

13 Last Character First reverse(in s:string) if (string is empty) do nothing else { display last character in the string reverse(s minus the last character) String Output cat t ca ta c tac ""

14 Code: Reverse Display void DisplayString(string str) { uint len = str.length(); if (len = 0) { cout << str[len - 1]; DisplayString(str.substr(0, len 1));

15 Fibonacci f(n) = f(n-1) + f(n-2) for n>2 f(2) = 1 f(1) = 1 The base case here is the value 1 for the first two fibonacci numbers. The recursive step is a combination of f(n-1) and f(n-2).

16 Code: Fibonacci double Fib(const int n) { // base case if (n <= 2) { return (1); else { // recursive step return ( Fib(n - 1) + Fib(n - 2) );

17 Fibonacci Traced 8 fib(6) = fib(5) + fib(4) 5 fib(5) = fib(4) + fib(3) fib(4) = fib(3) + fib(2) 3 3 fib(4) = fib(3) + fib(2) fib(3) = fib(2) + fib(1) 2 2 fib(3) = fib(2) + fib(1) fib(2) = fib(3) = fib(2) + fib(1) fib(2) = 1 1 fib(2) = 1 1 fib(1) = 1 1 fib(2) = 1 1 fib(1) = fib(2) = 1 fib(1) = 1 1

18 Find Min if (array has only one item) min(array) is that item else min(array) is the smallest of the first item and min(array minus first item) min(2,1,4,5) <? min(2,1,4) <? min(2,1) <? min(2) <? 2 min(2)

19 Code: FindMin listtype FindMin(const list ilist, const int len) { if (len == 1) { return (ilist[len - 1]); else { listtype cur = ilist[len - 1]; listtype min = FindMin(ilist, len - 1); return ( (min < cur)? min : cur);

20 Binary Search binarysearch(in anarray:arraytype, in value:itemtype) if (anarray is of size 1) Determine if anarray's item is equal to value else { Find the midpoint of anarray Determine which half of anarray contains values if (value is in the first half of anarray) binarysearch(first half of anarray, value) else binarysearch(second half of anarray, value)

21 Code: BinarySearch bool BinarySearch(const ilist list, const int first, const int last, const listtype key, int& posfound) { int mid = (first + last) / 2; // base case if (last < first) { return (false); else if (key == list[mid]) { posfound = mid; return (true);

22 Code: BinarySearch else if (key < list[mid]) { // key in lower half return (BinarySearch(list, first, mid - 1, key, posfound)); else { // key in upper half return (BinarySearch(list, mid + 1, last, key, posfound));

23 Binary Search Traced binarysearch(-4, -2, -1, 3, 5, 6, 15, 21, 25): key = -1 first:0 last:8 mid:4 arr[mid]:5 posfound:? T binarysearch(-4, -2, -1, 3): key = -1 first:0 last:3 mid:1 arr[mid]:-2 posfound:? T binarysearch(-1, 3): key = -1 first:2 last:3 mid:2 arr[mid]:-1 posfound:2 T

24 Towers of Hanoi You have three poles and n disks. The disks are of different size with the largest at the bottom. The challenge is to move all the disks, from a source pole to a destination pole, using the third pole as a holding place. A disk of a larger size cannot be on top of a disk of a smaller size. Assume towers(n, A, B, C) is our initial problem of moving n disks from the source pole, A, to the destination pole B, using pole C as a place holder. towers(n-1,a,c,b) towers(1,a,b,c) towers(n-1,c,b,a)

25 Code: Towers void towers(const int n, const char source, const char destination, const char spare) { if (n == 1) { cout << "Move from " << source << " to " << destination << endl; else { towers(n - 1, source, spare, destination); towers(1, source, destination, spare); towers(n - 1, spare, destination, source);

26 Code: FloodFill int image[16][16] = { {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, {1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, {1,1,1,1,1,1,1,0,0,1,0,1,1,1,1,1, {1,1,1,1,1,1,0,1,1,1,1,0,1,1,1,1, {1,1,1,1,0,0,1,1,1,1,1,1,0,1,1,1, {1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,1, {1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0, {0,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0, {0,1,1,1,1,1,1,1,1,0,0,1,1,1,0,1, {0,1,1,1,0,1,1,1,0,1,1,0,1,1,0,1, {0,1,1,0,1,0,1,1,0,1,1,1,0,0,1,1, {1,0,0,1,1,0,1,1,0,1,1,1,1,0,1,1, {1,0,1,1,1,0,1,0,1,1,1,1,1,1,1,1, {1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, {1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1, {1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1, ;

27 Code: FloodFill void DisplayImage(void); void FloodFill (int x, int y); bool Filled(int x, int y); void Color(int x, int y); void main(void) { DisplayImage(); FloodFill(6, 6); DisplayImage(); void FloodFill (int x, int y) { if ( Filled(x, y) ) { Color(x, y); FloodFill(x-1, y); // left FloodFill(x+1, y); // right FloodFill(x, y-1); // up FloodFill(x, y+1); // down

28 Code: FloodFill void DisplayImage(void) { for (int y = 0; y < 16; y++) { for (int x = 0; x < 16; x++) { cout << image[y][x]; cout << endl; cout << endl << endl;

29 Code: FloodFill bool Filled(int x, int y) { bool isfilled = true; cout << "Checking: " << y << "," << x << endl; if (image[y][x] == 1) { isfilled = false; return (isfilled); void Color(int x, int y) { image[y][x] = 0;

30 Closing Remarks Recursion is very elegant, but can also be very inefficient. Recursion can be inefficient for two reasons: The overhead associated with function calls. The inefficiency of the solution itself (see the fibonacci example). Basically, use recursion when there is no elegant iterative solution, and the recursive solution is not cost prohibitive.

Recursion Solution. Counting Things. Searching an Array. Organizing Data. Backtracking. Defining Languages

Recursion Solution. Counting Things. Searching an Array. Organizing Data. Backtracking. Defining Languages Recursion Solution Counting Things Searching an Array Organizing Data Backtracking Defining Languages 1 Recursion Solution 3 RECURSION SOLUTION Recursion An extremely powerful problem-solving technique