1 / 16

Chapter 5 Recursion

Chapter 5 Recursion. Recursion can be a very effective technique for solving what would otherwise be extremely elaborate problems. Sample recursive applications include:. Backtracking algorithms. Programming language definition. Matrix operations.

casey
Download Presentation

Chapter 5 Recursion

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter 5 Recursion Recursion can be a very effective technique for solving what would otherwise be extremely elaborate problems. Sample recursive applications include: • Backtracking algorithms. • Programming language definition. • Matrix operations. In addition, a solid understanding of recursion is helpful in analyzing the time complexity of algorithms. Recursion-related analysis techniques include: • Mathematical induction. • Recurrence relations. Chapter 5 - Recursion

  2. Boundary pixel LRUD-visited pixel Seed pixel Recursive Backtracking: Flood Fill Algorithm Starting with a “seed” pixel that’s inside a polygonal region, recursively visit the four adjacent pixels, coloring any that haven’t been colored, and that aren’t on the polygon’s boundary. Reaching the boundary is the recursion’s termination condition. 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 } } Chapter 5 - Recursion

  3. Languages, in particular programming languages, are defined by their grammars, sets of recursive rules which provide syntax. Recursive Grammars Example: A Simple Calculator Grammar program: END expr_list END expr_list: expression ; expression ; expr_list expression: term + expression term – expression term term: primary / term primary * term primary primary: NUMBER NAME NAME = expression - primary ( expression ) Using this grammar, the following is a syntactically correct calculator program: pi = 3.1416; rad = 2.5; ht = 10; area = pi * rad * rad; surfacearea = 2 * (area + pi * rad * ht); END • Recursive grammars are also prominent in more sophisticated languages, making the following language features possible: • nested loops, conditionals, function calls • cascaded operators (<<, >>, =, etc.) • multiple cases in a switch statement Chapter 5 - Recursion

  4. Recursive Matrix Operations Many matrix operations can be defined recursively, using combinations of submatrix operations to implement the large matrix operation. Example: Determinants                          Note that a matrix’s determinant is used to determine, among other things, whether it’s invertible. Chapter 5 - Recursion

  5. Recursive Determinant Program Example ///////////////////////////////////// // Class definition file: matrix.h // // The matrix class has two data // // members: a square array of int- // // eger values (all between 0 and // // 9), and an integer indicating // // the array size. Its member // // functions include constructors, // // functions to set and access // // specific array elements, a // // function to access a subarray, // // a recursive determinant func- // // tion, and an output operator. // ///////////////////////////////////// #ifndef MATRIX_H #include <fstream> usingnamespace std; typedef int elementType; const int MAX_GRID_SIZE = 7; class matrix { public: // Class constructors matrix() {size = 0;} matrix(const matrix &m); matrix(int sz); // Member functions int getSize() const { return size; } void setElement(int i, int j, elementType item); elementType getElement(int i, int j) { return table[i][j]; } elementType determinant(); friend ostream& operator << (ostream &os, const matrix &m); protected: // Data members elementType table[MAX_GRID_SIZE] [MAX_GRID_SIZE]; int size; // Member function matrix minor(int i, int j); }; #define MATRIX_H #endif Chapter 5 - Recursion

  6. //////////////////////////////////////////// // Class implementation file: matrix.cpp // // // // The implementation of the copy and // // initializing constructors, the setEle- // // ment, determinant, and minor member // // functions, and the output operator. // //////////////////////////////////////////// #include <cstdlib> #include <cassert> #include <fstream> #include <iomanip> #include <cmath> #include "matrix.h" usingnamespace std; // Copy constructor: Copies existing mat.// matrix::matrix(const matrix &m) { size = m.size; for (int row = 0; row < m.size; row++) for (int col = 0; col < m.size; col++) table[row][col] = m.table[row][col]; } // Initializing constructor: Sets *this // // up as a sz x sz matrix of zeros. // matrix::matrix(int sz) { size = sz; for (int row = 0; row < sz; row++) for (int col = 0; col < sz; col++) table[row][col] = 0; } // SetElement Member Function: Sets the // // (i,j) element of the matrix to item. // void matrix::setElement(int i, int j, elementType e) { assert ((0<=i) && (i<size) && (0<=j) && (j<size)); table[i][j] = e; } // Determinant Member Function: Calculates // // & returns the determinant of the matrix. // elementType matrix::determinant() { elementType value = 0; if (size == 1) return table[0][0]; for (int col = 0; col < size; col++) { value += (elementType)pow(-1, 0+col) * table[0][col] * minor(0, col).determinant(); } return value; } Notice how the size×size matrix is being evaluated recursively by using the top row to expand into size (size-1)×(size-1) submatrices. Chapter 5 - Recursion

  7. // Minor Member Function: If *this is // // an nXn matrix, then this returns // // the (n-1)X(n-1) matrix that is // // *this w/row i & column j removed. // matrix matrix::minor(int i, int j) { int subrow, subcol; assert (size > 1); matrix submat(size-1); subrow = 0; for (int row = 0; row < size; row++) { subcol = 0; if (row != i) { for (int col = 0; col < size; col++) if (col != j) { submat.setElement(subrow, subcol, table[row][col]); subcol++; } subrow++; } } return submat; } // Output Operator: Outputs matrix // // as a grid of size rows with // // size columns in each row. // ostream& operator << (ostream &os, const matrix &m) { for (int row = 0; row < m.getSize(); row++) { for (int col = 0; col < m.getSize(); col++) os << setw(4) << m.table[row][col]; os << endl; } return os; } Chapter 5 - Recursion

  8. //////////////////////////////////////////////////// // Program file: matrixDriver.cpp // // This program tests the matrix class by // // creating a random matrix of a user-specified // // size, outputting it, & taking its determinant. // //////////////////////////////////////////////////// #include <iostream> #include <iomanip> #include <ctime> #include <cstdlib> #include "matrix.h" usingnamespace std; int generateRandomNumber(int lowerBound, int upperBound); // The main function randomly generates & outputs // // a square matrix,, & determines its determinant.// void main() { int gridSize; cout << "SPECIFY THE MATRIX SIZE (a positive " << "integer less than " << MAX_GRID_SIZE+1 << "): "; cin >> gridSize; while ((gridSize<1) || (gridSize>MAX_GRID_SIZE)) { cout << "SORRY, ONLY VALUES BETWEEN 1 AND " << MAX_GRID_SIZE << " ARE ACCEPTED>\n“; cout << "SPECIFY THE MATRIX SIZE (a positive " << "integer less than " << MAX_GRID_SIZE+1 << "): "; cin >> gridSize; } matrix grid(gridSize); for (int row=0; row<gridSize; row++) for (int col=0; col<gridSize; col++) grid.setElement(row, col, generateRandomNumber(0,9)); cout << endl << "MATRIX:" << endl << grid << endl << endl; cout << "DETERMINANT: " << grid.determinant() << endl << endl; } // The generateRandomNumber function // // randomly generates an integer in the // // range between the parameterized low- // // erBound & upperBound values (inclu- // // sive). The first time it is called, // // it seeds stdlib.h's random number // // generation function rand(). // int generateRandomNumber(int lowerBound, int upperBound) { static bool firstTime = true; long int randomNumberSeed; if (firstTime) { time(&randomNumberSeed); srand(randomNumberSeed); firstTime = false; } return (lowerBound + int((upperBound - lowerBound) * (float(rand()) / RAND_MAX))); } Chapter 5 - Recursion

  9. Chapter 5 - Recursion

  10. Mathematical Induction A mathematical “cousin” to recursion is the concept of induction. When you want to prove that something is true for all integer values, beginning at a specific value n0, perform the following steps: Step One: Prove The Base Case Formally demonstrate that it’s true for that smallest value, n0. Step Two: Assume For Some General Case Assume that the it’s true for all values through k, where kis at leastn0. Step Three: Prove For The Next Case Use the assumption that it’s true for smaller cases to prove that it’s also true for k+1. Chapter 5 - Recursion

  11. Induction Example Theorem A: i = 1,n i = ½n(n + 1) for all n  1. Proof (by induction): • Step One (Prove for the base case): For n = 1,  i = 1,1 i = 1 = ½(1)(1 + 1). • Step Two (Assume for some general case): Assume for n = k:  i = 1,k i = ½k(k + 1). • Step Three (Prove for the next case): Prove for n = k + 1: •  i = 1,k+1 i = (k + 1) +  i = 1,k i • = (k + 1) + ½k(k + 1) • (by the assumption for case k) • = ½(2)(k + 1) + ½k(k + 1) • = ½(k + 1)(k + 2) • = ½(k + 1)((k + 1) + 1). Chapter 5 - Recursion

  12. Why Does Induction Work? To prove that  i = 1,n i = ½n(n + 1) for all n  1, we started by proving that it was true for n = 1. Once we accomplished that, we assumed that it was true for some arbitrary value k and then proved that that made it true for the next value: k + 1. In essence, this last proof causes the truth of the theorem to “cascade” through all remaining values. Proof that if it’s true for n = k, then it’s also true for n = k + 1 and so on... TRUE FOR n = 1: 1 = ½(1)(2) TRUE FOR n = 2: 1 + 2 = ½(2)(3) TRUE FOR n = 3: 1+2+3 = ½(3)(4) TRUE FOR n = 4: 1+2+3 +4 = ½(4)(5) TRUE FOR n = 5 : 1+2+3 +4+5 = ½(5)(6) Letting k = 1 Letting k = 2 Letting k = 3 Letting k = 4 Chapter 5 - Recursion

  13. What’s Wrong With This Induction? Theorem Z:For any group of n people, all n have the same height. Proof (by induction): • Step One (Prove for the base case): For n = 1, the group consists of a single person, so the entire group obviously has the same height. • Step Two (Assume for some general case): Assume for n = k: Any group of k people have the same height. • Step Three (Prove for the next case): Prove for n = k + 1: Given a group of k + 1 people, remove one person. The resulting group of k people must, by the inductive hypothesis, have the same height. Reinsert the person that was removed and then remove a different person. The resulting group of k people must also have the same height. Thus, all k + 1 people must have the same height! Chapter 5 - Recursion

  14. Recurrence Relations One of the bridges between recursion and induction is the recurrence relation, which can be used to determine the execution time of a recursive function. int powerOf2(const int &n) { if (n == 0) return 1; return powerOf2(n-1) + powerOf2(n-1); } Assuming that the execution time for arithmetic operations, condition checking, and returning are all the same, let’s also assume that there is a function T(n) such that it takes T(k) time to execute powerOf2(k). T(0) = 2 T(k) = 5 + 2T(k-1) for all k > 0 Examination of the code above allows us to conclude the following two facts: Chapter 5 - Recursion

  15. T(0) = 2 T(k) = 5 + 2T(k-1) for all k > 0 Using mathematical induction, we can prove that: T(k) = 7(2k)-5for all k 0 • Step One (Prove for the base case): For n = 0, we already know that T(0) = 2, and 7(20)-5 also evaluates to 2. • Step Two (Asume for some general case): Assume for n = k: T(k) = 7(2k)-5. • Step Three (Prove for the next case): Prove for n = k + 1: We know that T(k+1) = 5 + 2T(k), and we’re assuming that T(k) = 7(2k)-5, so we can conclude that T(k+1) = 5 + 2(7(2k)-5) = 7(2k+1)-5, which is what we wanted. Chapter 5 - Recursion

  16. One More Example... Let’s try the same trick on this alternate form of the function. int powerOf2(const int &n) { if (n == 0) return 1; return 2*powerOf2(n-1); } Using the same assumptions as before, we get the following recurrence relation: T(0) = 2 T(k) = 4 + T(k-1) for all k > 0 This time, however, mathematical induction tells us that: T(k) = 4k+2for all k 0 Chapter 5 - Recursion

More Related