Download presentation

Presentation is loading. Please wait.

Published byJaxon Herrin Modified over 2 years ago

1
COSO 1030 Section 4 Recursion

2
What is about Towers of Hanoi Divide and Conquer Strategy Recursion and Induction Thinking Recursively Recursion Pitfalls Analyze Efficiency of Recursion Tail Recursion Elimination

3
Towers of Hanoi Move n disks from one peg to another with a help peg, can’t put a big disk on a small Mark pegs as source, destination and spare Or simply 1, 2 and 3 Print each move by saying “Move disk k from peg i to j”.

4
Divide and Conquer If there is only one disk, just move it. If we can move n-1 disks from source to spare, then we can move the biggest one from source to destination. And the problem size reduced by 1, we only need to move n-1 disks from spare to destination using source as helper

5
Pseudo Code (level 1) /** * Towers of Hanoi * @param n int – n disks * @param I int – source peg * @param j int – destination peg * @param k int – spare peg * print out each move */ Void hanoi(int n, int I, int j, int k)

6
{ /* divide */ if( n == 1) { print(“Move ” + n + “th disk from ”+ i + “ to ” + j); } else { // 1. move n-1 disks from i to k using j for help // 2. move nth disk from i to j // 3. move n-1 disks from k to j using i. } The sub problem 2. is easy to solve print(“Move ” + n + “th disk from ”+ i + “ to ” + j); To the 1 and 3, problem size is n-1

7
Conquer Solve Sub Problems Recursively To the 1: – Move n-1 disks from i to k using j – hanoi(n-1, i, k, j); To the 3: – Move n-1 disks from k to j using I – hanoi(n-1, k, j, I);

8
void hanoi(int n, int i, int j, int k) { /* merge */ if( n == 1) { print(“Move ” + n + “th disk from ”+ i + “ to ” + j); } else { // 1. move n-1 disks from i to k using j for help hanoi(n-1, i, k, j); // 2. move nth disk from i to j print(“Move ” + n + “th disk from ”+ i + “ to ” + j); // 3. move n-1 disks from k to j using i. hanoi(n-1, k, j, i); }

9
Recursion A function call it self directly or indirectly Recursive Function Termination – If it is defined on Natural numbers (N) A sequence with a minimal value – Base - the minimal value – N with 0 as base – Can’t recursively calculate the function on base – Any other well defined sequence can be mapped to a sub set of N

10
Recursion and Induction Inductive definition of String – String ::= EMPTY – String ::= String + CHAR Recursively counts space characters in a string int numOfSpaceCh(String string) { if(string == null) { return 0; // base } else { int n = numOfSpaceCh(string.substring(1)); // recursion return ((string.charAt(0) == ‘ ’) ? 1: 0) + n; // merge }

11
Think Recursively Divide into small problem(s) – Half and half – Head and tail – Random divide – Cut one at end Solve base directly Recursively solve sub problem(s) Merge the result

12
Recursion Pitfalls Infinite recursion – Not well ordered …, -n, -(n-1), …, -2, -1, 0 – hanoi(0, 1, 2, 3) Exponent complexity class – Hanoi(n) is O(2^n) – Fibonacci(n) could be O(2^n)

13
Analyze Recursion Efficiency Recursion Efficiency depends on – Number of recursive calls – Size reduced Hanoi(n) – Has 2 recursive calls – Size reduced by 1 – O(2*O(Hanoi(n-1))) – O(2^n)

14
Inductive Proof There exists K and n0 such that for any n >= n0, K 2^n <= Hanoi(n) There exists K’ and n0’ such that for any n >= n0’, Hanoi(n) <= K’ 2^n Let K = 1 and n0 = 2 Base n = n0: if; Hanoi(1); print; Hanoi(1); 2^2 = 4 = Steps of Hanoi(2) Use SofH(n) for Steps of Hanoi(n)

15
Induction Assume for any m = n - 1, m >= n0, 2^m <= SofH(m) SofH(m + 1) are no less than SofH(m) + 1 + SofH(m). By assumption 2^m <= SofH(m), we get SofH(m+1)<= 2 * 2^m = 2 ^(m+1) Conclusion: for any n > n0 Steps of Hanoi(n) >= 2 ^ n.

16
O(numOfSpaceCh()) One recursive call Length reduced by 1 It is O(n) where n is the length of a string 1 * Steps of numOfSpaceCh(n-1)

17
Tail Recursion A recursive function is tail recursion, if – It has only one recursive call – And the call is the last statement of the function numOfSpaceCh is a tail recursive function Iteration version int n = 0; for (int I = 0; I < string.length; I ++) { if (string.charAt(I) == ‘ ’) n++; }; return n;

18
Tail Recursion Elimination Recursive Version F(n) { if (n == 0) base; else { m = non-recursive(n); F(m); // m < n } Iteration Version F(n) { base; while (n != 0) { n = non-recursive(n); }

19
Why Eliminate Recursion Efficiency – Tail Recursion O(n) Time, O(n) Stack Space – Iteration O(n) Time, O(1) Stack Space

20
Summary Recursion – A Powerful Tool Apply Divide and Conquer Strategy Inductive Definition, Proof and Recursive Computation How to Efficiently Divide Problems Analyze Computation Complexity Avoidable Pitfalls Eliminate Tail Recursion

Similar presentations

OK

Recursion –a programming strategy for solving large problems –Think “divide and conquer” –Solve large problem by splitting into smaller problems of same.

Recursion –a programming strategy for solving large problems –Think “divide and conquer” –Solve large problem by splitting into smaller problems of same.

© 2018 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on cartesian product business Ppt on being creative youtube Ppt on limitation act 1939 Ppt on content development training Store design and display ppt online Topics for ppt on environmental problems Ppt on automobile related topics about work Ppt on nuclear waste in india Ppt on centring point Ppt on product advertising image