1. Recursion
Data Structure
Submitted By:-
Dheeraj Kataria

2. Recursion Nested Recursion
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:
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

3. Recursion Nested Recursion The Ackermann function
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.

4. Recursion Nested Recursion The Ackermann function
A(0,0)=0+1=1,A(0,1)=2,A(1,0)=A(0,0)=1,
A(1,1)=A(0,A(1,0))=A(0,1)=3
A(1,2)=A(0,A(1,1))=A(0,2)=4
A(2,1)=A(1,A(2,0))=A(1,A(1,0))=A(1,1)=5
A(3,m)=A(2,A(3,m-1))=A(2,A(2,A(3,m-2)))=…=2m+3-3

5. Recursion Excessive Recursion
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
void Fibonacci(int n) {
If (n<2) return 1;
else
return Fibonacci(n-1)+Fibonacci(n-2); }

6. Recursion
Excessive Recursion
Many repeated computations

7. Recursion
Excessive Recursion

8. Recursion Excessive Recursion 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;

9. Recursion
Excessive Recursion

10. Recursion Excessive Recursion
We can also solve this problem by using a formula discovered by
A. De Moivre.
Can be neglected when n is large
The characteristic formula is :-
The value of is approximately

11. Recursion Backtracking
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”

12. Recursion Backtracking
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.

13. Recursion Backtracking
The Eight Queens Problem
Place 8 queens on an 8 by 8 chess board so that no two of them are on the same row, column, or diagonal

14. Recursion
Backtracking
The Eight Queens Problem

15. Recursion Backtracking 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 */ }

16. Recursion Backtracking The Eight Queens Problem Natural Implementation1 1 1 1 1 1 1 1 Q Q 1 1 1 1 1 1 1 1 1 1 1 1 1 1 Q 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 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
Initialization
The first queen
The second queen

17. Recursion Backtracking The Eight Queens Problem Natural ImplementationQ Q Q Q Q Q Q Q 1 1 1 1 Q Q 1 1 1 1 1 1 1 Q 1 1 1 Q 1 1 1 1 1 1 1 1 1 1 1
The third queen
The fourth queen
The 5th & 6th queen
Have to backtrack now!
This would be queen now.

18. Recursion Backtracking 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.

19. Recursion Backtracking The Eight Queens Problem
Simplified data structure
A 4 by 4 chessboard
Row-column = constant for each diagonal

20. Recursion
Backtracking
The Eight Queens Problem

21. Recursion
Backtracking
The Eight Queens Problem

22. Recursion
Backtracking
The Eight Queens Problem

23. Recursion
Backtracking
The Eight Queens Problem

24. Recursion
Backtracking
The Eight Queens Problem

25. Why Recursion?
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.

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. Why Recursion?
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.

28. Why Recursion?
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.

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.

33. Thank
You!!