Recursion Examples. Factorial Recursive: Factorial Iterative: #include <iostream> using namespace std; long fact(long n) { if (n == 1) return 1;

Size: px

Start display at page:

Download "Recursion Examples. Factorial Recursive: Factorial Iterative: #include <iostream> using namespace std; long fact(long n) { if (n == 1) return 1;"

Abigail Cannon
5 years ago
Views:

1 Recursion Examples Factorial Recursive: long fact(long n) if (n == 1) return 1; return n*fact(n-1); int main() long n; cout << "Input n: "; cin >> n; cout << n << "! = " << fact(n) << endl; return 0; Factorial Iterative: long fact(long n) long num = 1; for (int i = 1; i <= n; i++) num = num*i; return num; int main() long n; cout << "Input n: "; cin >> n; cout << n << "! = " << fact(n) << endl; return 0; 1

2 Fibonacci Sequence Recursive: int fib(int n) if ((n == 1) (n == 2)) return 1; return fib(n-1)+fib(n-2); int main() long n; cout << "Input n: "; cin >> n; cout << "Fibonacci Number " << n << " is " << fib(n) << endl << endl; cout << "The first " << n << " Fibonacci Numbers are " << endl; for (int j = 1; j <= n; j++) cout << fib(j) << " "; return 0; Fibonacci Sequence Iterative: long fib(long n) long backone = 1; long backtwo = 1; long num = 1; for (int i = 3; i <= n; i++) num = backone + backtwo; backtwo = backone; backone = num; return num; int main() SAME AS ABOVE 2

3 Divisibility by 9: int add_digits(int n) int sum = 0; while (n > 0) sum += (n % 10); n = n/10; return sum; bool isdiv9(int num) if (num == 9) return true; else if (num > 9) return isdiv9(add_digits(num)); return false; int main() long n; cout << "Input n: "; cin >> n; if (isdiv9(n)) cout << n << " is divisible by 9." << endl; else cout << n << " is not divisible by 9." << endl; return 0; 3

4 Towers of Hanoi Example: /* * Hanoi_Ex01.cpp * Simple Towers of Hanoi example. * Author: Don Spickler * Created: January 17, 2011 * Current: January 17, 2011 */ #include <string> void hanoi(int n, const std::string& initneedle, const std::string& endneedle, const std::string& tempneedle) if (n == 1) std::cout << "move " << initneedle << " to " << endneedle << std::endl; else hanoi(n-1, initneedle, tempneedle, endneedle); std::cout << "move " << initneedle << " to " << endneedle << std::endl; hanoi(n-1, tempneedle, endneedle, initneedle); int main() int n; string beginneedle = "A", middleneedle = "B", endneedle = "C"; cout << "Enter the number of disks: "; cin >> n; cout << "The solution for n = " << n << endl; hanoi(n, beginneedle, endneedle, middleneedle); return 0; 4

5 Advanced Recursion Applications: Backtracking Support file for EightQueens and Maze: #ifndef EXCEPTION_CLASSES #define EXCEPTION_CLASSES #include <strstream> #include <string> class baseexception baseexception(const string& str = ""): msgstring(str) if (msgstring == "") msgstring = "Unspecified exception"; string what() const return msgstring; // protected allows a derived class to access msgstring. // chapter 13 discusses protected in detail protected: string msgstring; ; // failure to allocate memory (new() returns NULL) class memoryallocationerror: public baseexception memoryallocationerror(const string& msg = ""): ; // function argument out of proper range class rangeerror: public baseexception rangeerror(const string& msg = ""): ; // index out of range class indexrangeerror: public baseexception indexrangeerror(const string& msg, int i, int size): 5

6 ; baseexception() char indexstring[80]; ostrstream indexerr(indexstring, 80); indexerr << msg << " index " << i << " size = " << size << ends; // indexrangeerror can modify msgstring, since it is in // the protected section of baseexception msgstring = indexstring; // attempt to erase from an empty container class underflowerror: public baseexception underflowerror(const string& msg = ""): ; // attempt to insert into a full container class overflowerror: public baseexception overflowerror(const string& msg = ""): ; // error in expression evaluation class expressionerror: public baseexception expressionerror(const string& msg = ""): ; // bad object reference class referenceerror: public baseexception referenceerror(const string& msg = ""): ; // feature not implemented class notimplementederror: public baseexception notimplementederror(const string& msg = ""): ; 6

7 // date errors class dateerror: public baseexception dateerror(const string& first, int v, const string& last): baseexception() char datestr[80]; ostrstream dateerr(datestr, 80); ; dateerr << first << ' ' << v << ' ' << last << ends; // dateerror can modify msgstring, since it is in // the protected section of baseexception msgstring = datestr; // error in graph class class grapherror: public baseexception grapherror(const string& msg = ""): ; // file open error class fileopenerror: public baseexception fileopenerror(const string& fname): baseexception() char errorstr[80]; ostrstream fileerr(errorstr, 80); ; fileerr << "Cannot open \"" << fname << "\"" << ends; // fileopenerror can modify msgstring, since it is in // the protected section of baseexception msgstring = errorstr; // error in graph class class fileerror: public baseexception fileerror(const string& msg = ""): ; #endif // EXCEPTION_CLASSES 7

8 Support file for EightQueens and Maze: #ifndef MATRIX_CLASS #define MATRIX_CLASS #include <vector> #include "d_except.h" template <typename T> class matrix matrix(int numrows = 1, int numcols = 1, const T& initval = T()); // constructor. // Postcondition: create array having numrows x numcols elements // all of whose elements have value initval vector<t>& operator[] (int i); // index operator. // Precondition: 0 <= i < nrows. a violation of this // precondition throws the indexrangeerror exception. // Postcondition: if the operator is used on the left-hand // side of an assignment statement, an element of row i // is changed const vector<t>& operator[](int i) const; // version for constant objects int rows() const; // return number of rows int cols() const; // return number of columns void resize(int numrows, int numcols); // modify the matrix size. // Postcondition: the matrix has size numrows x numcols. // any new elements are filled with the default value of type T private: int nrows, ncols; // number of rows and columns ; vector<vector<t> > mat; // matrix is implemented as nrows vectors (rows), // each having ncols elements (columns) template <typename T> matrix<t>::matrix(int numrows, int numcols, const T& initval): nrows(numrows), ncols(numcols), mat(numrows, vector<t>(numcols,initval)) // non-constant version. provides general access to matrix 8

9 // elements template <typename T> vector<t>& matrix<t>::operator[] (int i) if (i < 0 i >= nrows) throw indexrangeerror( "matrix: invalid row index", i, nrows); return mat[i]; // constant version. can be used with a constant object. // does not allow modification of a matrix element template <typename T> const vector<t>& matrix<t>::operator[] (int i) const if (i < 0 i >= nrows) throw indexrangeerror( "matrix: invalid row index", i, nrows); return mat[i]; template <typename T> int matrix<t>::rows() const return nrows; template <typename T> int matrix<t>::cols() const return ncols; template <typename T> void matrix<t>::resize(int numrows, int numcols) int i; // handle case of no size change with a return if (numrows == nrows && numcols == ncols) return; // assign the new matrix size nrows = numrows; ncols = numcols; // resize to nrows rows mat.resize(nrows); // resize each row to have ncols columns for (i=0; i < nrows; i++) mat[i].resize(ncols); #endif // MATRIX_CLASS 9

10 Eight Queens Header File: #ifndef EIGHT_QUEENS_PROBLEM #define EIGHT_QUEENS_PROBLEM #include <vector> #include "d_matrix.h" // can a queen at (row,col) be attacked by any of the // non-attacking queens in columns 0 to col-1? bool safelocation(int row, int col, const vector<int>& queenlist) int qrow, qcol; for (qcol = 0; qcol < col; qcol++) // check previous columns only qrow = queenlist[qcol]; if (qrow == row) // same row return false; else if (qcol == col) // same col return false; // can they attack on a diagonal? else if(qcol-qrow == col-row qcol+qrow == col+row) return false; return true; // place a queen in columns col through 7 bool placequeens(vector<int>& queenlist, int col) int row; bool foundlocation; if (col == 8) // stopping condition foundlocation = true; else foundlocation = false; // start with row 0 row = 0; while (row < 8 &&!foundlocation) // check whether cell (row, col) is safe; if so, // assign row to queenlist and call placequeens() // for next column; otherwise, go to the next row if (safelocation(row,col,queenlist) == true) // found good location queenlist[col] = row; // recursive step. try to place queens in columns col+1 // through 7 foundlocation = placequeens(queenlist,col+1); 10

11 if (!foundlocation) // use next row since current one does not lead // to a solution row++; else // current row fails. go to the next row row++; // end while // pass success or failure back to previous col return foundlocation; // try to find a solution to the 8-Queens problem starting // with a queen at (row,0) bool queens(vector<int>& queenlist, int row) // place first queen at (row,0) queenlist[0] = row; // locate remaining queens in columns 1 through 7 if (placequeens(queenlist, 1)) return true; else return false; class chessboard chessboard(); // default constructor void setqueens(const vector<int>& queenlist); // set queens on board at cells (queenlist[col], col) // 0 <= col < 8 void clearboard(); // clear the board void drawboard() const; // draw the board using symbols 'Q' or '-' private: // simulates chess board matrix<bool> board; ; // constructor. initialize board to blanks chessboard::chessboard(): board(8,8) clearboard(); 11

12 // assign queens at locations (queenlist[col],col), // 0 <= col < 8 void chessboard::setqueens(const vector<int>& queenlist) clearboard(); for (int col = 0; col < 8; col++) board[queenlist[col]][col] = true; void chessboard::clearboard() int i,j; for(i=0; i < 8; i++) for(j=0; j < 8; j++) board[i][j] = false; // draw the chess board void chessboard::drawboard() const int i,j; cout <<" " << endl; for (i = 0; i < 8; i++) cout << i << " "; // draw the squares in current row for (j = 0; j < 8; j++) if (board[i][j] == true) cout << " Q"; else cout << " -"; cout << endl; #endif // EIGHT_QUEENS_PROBLEM 12

13 Eight Queens Main: // the program solves the 8-Queens problem. it prompts the user for // the starting row for the queen in column 0 and calls the recursive // backtracking function queens() to determine if there is a solution. // if there is a solution, the position of the queens is passed to // the chessboard object, board, and a call to its drawboard() function // shows the placement of the queens #include "d_queens.h" int main () int row; vector<int> queenlist(8); chessboard board; // enter a starting row for queen in column 0 cout << "Enter row for queen in column 0: "; cin >> row; cout << endl; // see if there is a solution if (queens(queenlist, row)) board.setqueens(queenlist); // display the solution board.drawboard(); else cout << "No solution" << endl; return 0; Run: Enter row for queen in column 0: Q Q Q Q Q Q Q Q

14 Maze Program: #include <fstream> #include <string> #include <cstdlib> #include "matrix.h" void solvemaze(matrix<char> maze, matrix<char>& solmaze, int x, int y) if (maze[x][y] == 'F') maze[x][y] = '-'; solmaze = maze; else maze[x][y] = '-'; if ((x-1 >= 0) && ((maze[x-1][y] == ' ') (maze[x-1][y] == 'F'))) solvemaze(maze, solmaze, x-1, y); if ((y-1 >= 0) && ((maze[x][y-1] == ' ') (maze[x][y-1] == 'F'))) solvemaze(maze, solmaze, x, y-1); 'F'))) 'F'))) if ((x+1 < maze.rows()) && ((maze[x+1][y] == ' ') (maze[x+1][y] == solvemaze(maze, solmaze, x+1, y); if ((y+1 < maze.cols()) && ((maze[x][y+1] == ' ') (maze[x][y+1] == solvemaze(maze, solmaze, x, y+1); int main () string filename; cout << "Enter the maze filename: "; cin >> filename; fstream mazefile; mazefile.open(filename.c_str()); if (!mazefile) cerr << "Cannot open " << filename << endl; exit(1); char c; int rows = 0; int cols = 0; while(mazefile) mazefile.get(c); if (c == '\n') rows++; 14

15 if ((c!= '\n') && (rows == 0)) cols++; if (!mazefile) break; rows++; // Add 1 since the last return is not counted. cols++; // Add 1 so we can store the end line character in the maze. mazefile.close(); matrix<char> maze(rows, cols); // Load maze into matrix. mazefile.open(filename.c_str()); for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) mazefile.get(c); if (mazefile) maze[i][j] = c; mazefile.close(); // Find the S int sposx = 0; int sposy = 0; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) if (maze[i][j] == 'S') sposx = i; sposy = j; // Solve the maze. matrix<char> solmaze; solvemaze(maze, solmaze, sposx, sposy); // Write Result to Solution File string solfile = "Solution_" + filename; mazefile.open(solfile.c_str(), ios::out ios::trunc); if (!mazefile) cerr << "Cannot open " << solfile << endl; exit(1); for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) mazefile.put(solmaze[i][j]); mazefile.close(); return 0; 15

16 Run: Input File XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXX XXX XXXXXXXXX XXXXXXXXXXXXX XXXX XXXXX XXX XXX XX XXXXXXX XXXXXXXXXXXXXXXX XXXXX XX XXXXXXXXXXXXXXXXXXXXXXX X X XXX XX X XXXXXXX XXXXXXXXXXXXXXXX XXXXX XXXX XX XXX XXXXXXXX XXXXX XXXXXXXXXX XXXXXXXXX XX XXXXX XXXX XX XXX XXXXXXXXXX XX XXX XXX XXXX XX XXXXXXXXXXXXXXXXXXX XXXX XX XXX XXXX XXXXX XX X XXX XXX XX XXXXXXXXXXXXXXXXXXX XX XXXXXXXXXXX XXXX XX XXX XXXX XXXXX X XXX XXX XX X X XXXX XXXXXXXXXX XXXX XXXXXX XXXX XX XXX XXXX XXXXXXXXXX XXX XXX XX X X XXXXXXXXXX XXXX XXX XXXX XXXXXX XXXX XX XXX XXXX XXXXXXXXXX XXX XXX XX X X XXXX XXXX XXX XXXXXXXXXXX XXXXXX XXXX XX XXX XXXX XXXXXXXXXX F XXX XX X X XXXXX XXXX XX XXX XXXXXXXXXXX XXXXXX XXXX XX XXX XX XXXXX XXX XX X X XX XX XXXX XXXX XXX XXXXXXXXXXX XXXXXX XXXX XX XXX XX XXXXXXXXXX XXXXX XXX XX X X XX XX XXXX XXXX XXX XXXX XX XXX XX X X XXXXX XXX XX X XX XXXX XXXX XXXXXXXXXX XXXXXXXXXXXXXXXX XX XXX XX X XXXXXX X XXXXX XXX XX X XXXX XX XXXX X XXXX XXXXX XX XXXXXX XX XXX XX X X XX X XXXXX XXX XX XXXXXXXXX XXXX XXXX XXXX XXXXX XXXXXXXXX XXXXXX XX XXX XX X X X XX X XXXXX XXX XX XXXX XXXX XXXX XXXXX XXXXXXXXX XXXXXX XX XXX XX X X X XX X XXXXX XXX XXXXXXXXXXXXXXXXX XXXX XX XXXXXX XX XXX XX X X X XX X XXXXX XXX XXXXXXXXXXXXXXXXX XXXX XX XXXXXXXXXXXXXXXXXXXXXXXX XX XXX XX X X X XX X XXXXX XXX XXX XXXX XX XXXXXXXXXXXXXXXXXXXXXXXX XX XXX XX X X X XX X XXXXX XXX XXX XXXXXXXXXXXXXXXXXX XX XXX XX XXX XX X X X X X XXXXX XXX XXX XXXXX XX XXX XXXXXXXXXXXXXXXXXXXXXXX XXX XX X X XXXX X XXXXX XXX XXXXXXXXXXXXXXXX XXXXX XX XXX XXXXX XXX XXXXXX XXXXX XXX XX X X X XXXXX XXX XXXXXXX XXXXX XX XXX XXXXX XXX XXXXXX XXXXX XXXX XX X XXXXXXXX XXXXX XXX XXXXXXX XXXX XXXXXXXXX XX XXX XX X XXXXX XXX XX X XX XXXX XXXX XX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX S XX XXXX X XXXX XX XXXXXXX XXXXXX XXXX XXXXXXXXXXXXXX XXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XX XX XX XX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX Output File XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXX XXX XXXXXXXXX XXXXXXXXXXXXX XXXX XXXXX XXX XXX XX XXXXXXX-XXXXXXXXXXXXXXXX-XXXXX------XX XXXXXXXXXXXXXXXXXXXXXXX X X XXX XX X XXXXXXX-XXXXXXXXXXXXXXXX-XXXXX-XXXX-XX XXX XXXXXXXX XXXXX XXXXXXXXXX XXXXXXXXX-XX XXXXX-XXXX-XX XXX-XXXXXXXXXX-XX---XXX XXX---- XXXX-XX-XXXXXXXXXXXXXXXXXXX-XXXX-XX XXX-XXXX XXXXX-XX-X-XXX XXX-XX-XXXXXXXXXXXXXXXXXXX-XX XXXXXXXXXXX-XXXX-XX XXX-XXXX XXXXX----X-XXX XXX-XX-X X XXXX-XXXXXXXXXX-XXXX XXXXXX-XXXX-XX XXX-XXXX XXXXXXXXXX-XXX XXX-XX-X X-XXXXXXXXXX-XXXX-XXX XXXX XXXXXX-XXXX-XX XXX-XXXX XXXXXXXXXX-XXX XXX-XX-X X XXXX-XXXX-XXX-XXXXXXXXXXX XXXXXX-XXXX-XX XXX-XXXX XXXXXXXXXX---- XXX-XX-X X XXXXX-XXXX-XX -XXX-XXXXXXXXXXX XXXXXX-XXXX-XX XXX-XX XXXXX XXX-XX-X X XX XX-XXXX-XXXX-XXX-XXXXXXXXXXX XXXXXX-XXXX-XX XXX-XX XXXXXXXXXX XXXXX XXX-XX-X X XX XX-XXXX-XXXX-XXX XXXX-XX XXX-XX X X XXXXX XXX-XX-X XX-XXXX-XXXX-XXXXXXXXXX XXXXXXXXXXXXXXXX-XX XXX-XX X XXXXXX X XXXXX XXX-XX-X XXXX XX-XXXX-X -XXXX XXXXX XX XXXXXX-XX XXX-XX X X XX X XXXXX XXX-XX-XXXXXXXXX-XXXX-XXXX-XXXX XXXXX XXXXXXXXX XXXXXX-XX XXX-XX X X X XX X XXXXX XXX-XX XXXX-XXXX-XXXX XXXXX XXXXXXXXX XXXXXX-XX XXX-XX X X X XX X XXXXX XXX-XXXXXXXXXXXXXXXXX-XXXX-XX XXXXXX-XX XXX-XX X X X XX X XXXXX XXX-XXXXXXXXXXXXXXXXX-XXXX-XX XXXXXXXXXXXXXXXXXXXXXXXX-XX XXX-XX X X X XX X XXXXX XXX-XXX XXXX-XX XXXXXXXXXXXXXXXXXXXXXXXX-XX XXX-XX X X X XX X XXXXX XXX-XXX-XXXXXXXXXXXXXXXXXX-XX XXX XX XXX-XX X X X X X XXXXX XXX-XXX XXXXX-XX XXX-XXXXXXXXXXXXXXXXXXXXXXX XXX-XX X X XXXX X XXXXX XXX-XXXXXXXXXXXXXXXX-XXXXX-XX XXX-XXXXX XXX XXXXXX XXXXX XXX-XX X X X XXXXX XXX-XXXXXXX XXXXX-XX XXX-XXXXX XXX XXXXXX XXXXX XXXX-XX X XXXXXXXX XXXXX XXX-XXXXXXX-XXXX XXXXXXXXX-XX XXX XX X XXXXX XXX- XX-X XX XXXX XXXX-XX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX ----XX XXXX-X XXXX-XX XXXXXXX XXXXXX XXXX-XXXXXXXXXXXXXX-XXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XX XX XX XX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 16

Chapter 6 Recursion. The Concept of Recursion

Chapter 6 Recursion. The Concept of Recursion Data Structures for Java William H. Ford William R. Topp Chapter 6 Recursion Bret Ford 2005, Prentice Hall The Concept of Recursion An algorithm is recursive if it can be broken into smaller problems of