Download presentation

Published byClarence McGee Modified over 6 years ago

1
**Factorial Recursion stack Binary Search Towers of Hanoi**

Session 05: C# Recursion Factorial Recursion stack Binary Search Towers of Hanoi FEN AK IT: Softwarekonstruktion

2
**AK IT: Softwarekonstruktion**

Recursion In programming languages recursion is when a method is calling it self (recursion may be indirectly) Recursion often comes around when a problem can be solved using a divide and conquer strategy: If the problem is small, we can apply some simple (non-recursive) solution. (called “base case”) Otherwise the problem is divided into smaller sub problems of the same kind. The sub problems are then solved by applying the solution recursively to the sub problems. Eventually the sub problems become so small that the simple solution can be applied, and recursion terminates. When the sub problems are solved, the solutions to the sub problems are combined into a solution to the original problem. FEN AK IT: Softwarekonstruktion

3
**Recursion –Divide and Conquer**

If the problem is small, we can apply some simple (non-recursive) solution (called “base case”). Otherwise the problem is divided into smaller sub problems of the same kind. The sub problems are then solved by applying the solution recursively to the sub problems. Eventually the sub problems become so small that the simple solution can be applied, and recursion terminates. Note the similarities to loops Conquer: Simple sub problems are solved using the non-recursive solution When the sub problems are solved, the solutions to the sub problems are combined into a solution to the original problem. FEN AK IT: Softwarekonstruktion

4
**Example n! = n * (n-1)! for n > 0 n! = 1 for n = 0**

Many mathematical functions may be defined recursively. For instance, computing the factorial of an number n (n!): n! = n * (n-1)! for n > 0 n! = 1 for n = 0 The base case (simple problem) is when n=0 If n>0 the problem is divided into the subproblem of computing the factorial of n-1 The combine part is multiplying the result of (n-1)! by n. Note: There must be a base case, so recursion eventually stops. FEN AK IT: Softwarekonstruktion

5
**Recursive Factorial in C#**

public static long Fac(long n) { calls++; if (n == 0) return 1; else return n * Fac(n - 1); } FEN AK IT: Softwarekonstruktion

6
**Behind the Scenes: The Recursion Stack**

When a recursive method executes many activations of the method exist at the same time. The virtual machine is handling this by storing the different states of the method on a stack: Value of parameters and local variables Return address When a method is called, an activation is created and pushed onto the stack When a method returns, its activation is popped from the stack The current activation of the method is always the topmost on the stack, and it is the values of parameters, local variables etc. stored that is used. A stack is a list, where insert (push) and remove (pop) are done at the front of the list (stack top). Stack: top FEN AK IT: Softwarekonstruktion

7
**AK IT: Softwarekonstruktion**

Iterative Factorial Actual it is not very smart to compute the factorial of n recursively – a loop can do the job much more efficiently: public long FacIter(int n) { long fac = 1; for (int i = 2; i <= n; i++) fac = fac * i; return fac; } But is it more simple? public long Fac(int n) if (n == 0 || n == 1) return 1; else return n * Fac(n-1); } FEN AK IT: Softwarekonstruktion

8
**AK IT: Softwarekonstruktion**

Exercise Write a recursive method that computes the sum of the first n non-negative numbers. Hint: the sum may be define by: sum(n) = n + sum(n-1) for n > 0 sum(n) = 0 for n = 0 Draw pictures of the recursion stack when sum(3) is computed FEN AK IT: Softwarekonstruktion

9
Binary Search In a sorted random access (array based) data set it is possible to use binary search. Binary search can be formulated very simply using recursion: Strategy: If - the search set is empty Then - the searched element, s, is not in the set Else - inspect the middle element, m - If - m == s - Then - the element is found and we are done - Else - If - m > s - Then - search in the lower half of the set Else - search in the upper half of the set Note the recursive nature of this solution! FEN AK IT: Softwarekonstruktion

10
**AK IT: Softwarekonstruktion**

In C#… public static bool BinSearch(int l, int h, int x, int[] T) { //PRE T is sorted //Looking for x between l and h in T calls++; int m; if (l > h) return false; else m = (l + h) / 2; if (x == T[m]) return true; if (x > T[m]) return BinSearch(m + 1, h, x, T); return BinSearch(l, m - 1, x, T); } FEN AK IT: Softwarekonstruktion

11
**AK IT: Softwarekonstruktion**

The Towers of Hanoi Three pins: source, S target, T help, H 64 discs with decreasing diameters are to be moved from S to T observing the following rules: A larger disc can not be placed upon a smaller Only one disc can be moved at the time Algorithm? FEN AK IT: Softwarekonstruktion

12
**The Towers of Hanoi This yields a recursive solution Solution:**

Move 63 discs from S to H using T as help Move one disc from S to T Move 63 discs from H to T using S as help Now the problem is how to move the 63 discs. That must be easier: Move 62 discs… Move one disc This yields a recursive solution FEN AK IT: Softwarekonstruktion

13
**AK IT: Softwarekonstruktion**

The Algorithm in C# public static void Hanoi(int n, char s, char h, char d) { //Moves n disks from S(ource) to D(estination) using H(elp) //Do not try this for n much larger 16 calls++; if (n == 1) //System.Console.WriteLine("Move one disk from: " + s + " to:" + d); } else Hanoi(n - 1, s, d, h); Hanoi(n - 1, h, s, d); FEN AK IT: Softwarekonstruktion

14
**Efficiency of Recursive Algorithms**

Overhead in time due to call-return Overhead in space due to the recursion stack The Recursion Tree tells about complexity: The depth tells about memory space The number of nodes tells about running time FEN AK IT: Softwarekonstruktion

15
**AK IT: Softwarekonstruktion**

Examples Draw the recursion trees: Binary Search: O(log n) (time and space) Factorial of n: O(n) (time and space) Towers of Hanoi: O(2n) (time) O(n) (space) FEN AK IT: Softwarekonstruktion

16
**Recursive vs. Iterative Algorithms**

It is always possible to rewrite a recursive algorithm to an equivalent iterative which may be more efficient. But the iterative version is often more complicated, since one has to handle the recursion stack oneself. In some cases it is possible to find iterative algorithms that are more efficient and as simple as the equivalent recursive: Tail recursion: If the recursive call is the last statement in the algorithm, then there is no need for remembering the state of other active calls. The recursion can the be converted to a loop and there is no need for the recursion stack. Hence we get rid of the overhead to call-return and the overhead in space as well. FEN AK IT: Softwarekonstruktion

Similar presentations

© 2021 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google