- 2. A more complicated case of recursion is found in definitions in which a function is not only defined in terms of itself but it is also used as one of the parameters. Example: 4if))2(2( ,4if ,0if0 )( nnhh nn n nh h(1)=h(2+h(2))=h(14)=14 h(2)=h(2+h(4))=h(12)=12 h(3)=h(2+h(6))=h(2+6)=h(8)=8 h(4)=h(2+h(8))=h(2+8)=h(10)=10 Recursion • Nested Recursion
- 3. The Ackermann function otherwise))1,(,1( ,0,0if)1,1( ,0if1 ),( mnAnA mnnA nm mnA This function is interesting because of its remarkably rapid growth. It grows so fast that it is guaranteed not to have a representation by a formula that uses arithmetical operations such as addition, multiplication, and exponentiation. Recursion • Nested Recursion
- 5. Logical simplicity and readability are used as an argument supporting the use of recursion. The price for using recursion is slowing down execution time and storing on the run-time stack more things than required in a non-recursive approach. Example: The Fibonacci numbers .2if)1()2( ,2if1 ,1if1 )( iiFiF i i iF void Fibonacci(int n) { If (n<2) return 1; else return Fibonacci(n-1)+Fibonacci(n-2); } Recursion • Excessive Recursion
- 6. Many repeated computations Recursion • Excessive Recursion
- 8. void IterativeFib(int n) { if (n < 2) return n; else { int i = 2, tmp, current = 1, last = 0; for ( ; i<=n; ++i) { tmp= current; current += last; last = tmp; } return current; } } Recursion • Excessive Recursion
- 10. We can also solve this problem by using a formula discovered by A. De Moivre. The characteristic formula is :- 5 ) 2 51 () 2 51 ( )( nn nf Can be neglected when n is large Recursion • Excessive Recursion The value of is approximately -0.618034) 2 51 (
- 11. Suppose you have to make a series of decisions, among various choices, where • You don’t have enough information to know what to choose • Each decision leads to a new set of choices • Some sequence of choices (possibly more than one) may be a solution to your problem Backtracking is a methodical way of trying out various sequences of decisions, until you find one that “works” Recursion • Backtracking
- 12. Backtracking allows us to systematically try all available avenues from a certain point after some of them lead to nowhere. Using backtracking, we can always return to a position which offers other possibilities for successfully solving the problem. Recursion • Backtracking
- 13. Recursion • Backtracking Place 8 queens on an 8 by 8 chess board so that no two of them are on the same row, column, or diagonal The Eight Queens Problem
- 14. Recursion • Backtracking The Eight Queens Problem
- 15. The Eight Queens Problem Pseudo code of the backtracking algorithm PutQueen(row) for every position col on the same row if position col is available { place the next queen in position col; if (row < 8) PutQueen(row+1); else success; remove the queen from position col; /* backtrack */ } Recursion • Backtracking
- 16. The Eight Queens Problem Natural Implementation 1 Initialization 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 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 1 1 1 1 1 1 1 1 1 1 1 1 1 Q The first queen 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 1 1 0 1 1 1 1 1 0 1 0 1 1 1 1 1 1 0 Q The second queen 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 Q 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 1 0 0 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 1 0 0 1 0 0 1 1 1 1 0 0 Recursion • Backtracking
- 17. The Eight Queens Problem Natural Implementation Q The third queen 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 Q 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 Q 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 1 1 0 0 1 0 0 0 1 1 1 0 0 Q The fourth queen 0 0 0 0 0 0 0 0 0 0 Q 0 0 0 0 0 Q 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 Q 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 1 1 0 0 Q The 5th & 6th queen 0 0 0 0 0 0 0 0 0 0 Q 0 0 0 0 0 Q 0 0 0 0 0 0 0 0 0 0 Q 0 0 0 0 0 Q 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Q 0 0 Have to backtrack now!This would be queen now. Recursion • Backtracking
- 18. The Eight Queens Problem Natural Implementation The setting and resetting part would be the most time-consuming part of this implementation. However, if we focus solely on the queens, we can consider the chessboard from their perspective. For the queens, the board is not divided into squares, but into rows, columns, and diagonals. Recursion • Backtracking
- 19. The Eight Queens Problem Simplified data structure A 4 by 4 chessboard Row-column = constant for each diagonal Recursion • Backtracking
- 20. The Eight Queens Problem Recursion • Backtracking
- 21. The Eight Queens Problem Recursion • Backtracking
- 22. The Eight Queens Problem Recursion • Backtracking
- 23. Recursion • Backtracking The Eight Queens Problem
- 24. Recursion • Backtracking The Eight Queens Problem
- 25. • Usually recursive algorithms have less code, therefore algorithms can be easier to write and understand - e.g. Towers of Hanoi. However, avoid using excessively recursive algorithms even if the code is simple. • Sometimes recursion provides a much simpler solution. Obtaining the same result using iteration requires complicated coding - e.g. Quicksort, Towers of Hanoi, etc. Why Recursion?
- 26. Why Recursion? • Recursive methods provide a very natural mechanism for processing recursive data structures. A recursive data structure is a data structure that is defined recursively – e.g. Linked-list, Tree. Functional programming languages such as Clean, FP, Haskell, Miranda, and SML do not have explicit loop constructs. In these languages looping is achieved by recursion.
- 27. • Recursion is a powerful problem-solving technique that often produces very clean solutions to even the most complex problems. • Recursive solutions can be easier to understand and to describe than iterative solutions. Why Recursion?
- 28. • By using recursion, you can often write simple, short implementations of your solution. • However, just because an algorithm can be implemented in a recursive manner doesn’t mean that it should be implemented in a recursive manner. Why Recursion?
- 29. Limitations of Recursion • Recursive solutions may involve extensive overhead because they use calls. • When a call is made, it takes time to build a stackframe and push it onto the system stack. • Conversely, when a return is executed, the stackframe must be popped from the stack and the local variables reset to their previous values – this also takes time.
- 30. Limitations of Recursion • In general, recursive algorithms run slower than their iterative counterparts. • Also, every time we make a call, we must use some of the memory resources to make room for the stackframe.
- 31. Limitations of Recursion • Therefore, if the recursion is deep, say, factorial(1000), we may run out of memory. • Because of this, it is usually best to develop iterative algorithms when we are working with large numbers.
- 32. Main disadvantage of programming recursively • The main disadvantage of programming recursively is that, while it makes it easier to write simple and elegant programs, it also makes it easier to write inefficient ones. • when we use recursion to solve problems we are interested exclusively with correctness, and not at all with efficiency. Consequently, our simple, elegant recursive algorithms may be inherently inefficient.