Вы находитесь на странице: 1из 28

Recursion

Tuesday, September 26, 2006

Recursion
A recursive function is one that makes use of itself Every recursive function involves

base case(s), simple instance of the problem that can be solved directly crucial for termination recursive case(s). divide the problem into one or more simpler or smaller parts call the function (recursively) on each part combine the solutions of the parts into a solution for the problem
Comp 352: Data Structures and Algorithms

Designing a Recursive Algorithm


Consider the following questions: 1. How could you define the problem in terms of a smaller problem of the same type? 2. How would each recursive call affect the size of the problem? (size should decrease) 3. What instance(s) of the problem can serve as the base case? 4. As the problem size decreases, will you reach the base case?

Comp 352: Data Structures and Algorithms

Recursion: Advantages
For some problems, recursive solution may be more natural and simpler to write than using non-recursive solutions Example: The factorial function: n! = 1 (if n = 0) n! = n * (n-1)! (otherwise)

Comp 352: Data Structures and Algorithms

Recursion : Disadvantages
Calling a recursive function consumes more time and memory than non-recursive solution of the same problem It is easy to write inefficient recursive algorithms ==> High performance applications hardly ever use recursion

Comp 352: Data Structures and Algorithms

Watch Out
When using recursion, we must be careful not to create an infinite chain of function calls:
Oops! No termination condition

int factorial(int numb){ return numb * factorial(numb-1); } A recursive function must


Contain at least one non-recursive branch Eventually lead to a non-recursive branch


Comp 352: Data Structures and Algorithms

Fibonacci Sequence Example I


Fibonacci Sequence

Comp 352: Data Structures and Algorithms

Fibonacci Sequence Example II


int fib(int number) { if (number == 0) return 0; if (number == 1) return 1; return (fib(number-1) + fib(number-2)); } 8
Comp 352: Data Structures and Algorithms

Fibonacci Sequence Example III

Reference: [6]

Comp 352: Data Structures and Algorithms

Linear Recursion
A Linear Recursion is the simplest form of recursion.

Has one recursive call

Is used when an algorithm has a simple repetitive structure


Includes some basic step (usually first or last element) The remaining set has the same structure as the original one
Comp 352: Data Structures and Algorithms

10

Tail Recursion
A Tail Recursion is a special case of linear recursion

With the last operation being a recursive call

Tail Recursions can very often be easily transformed into an iteration

11

Comp 352: Data Structures and Algorithms

Binary Recursion
A Binary Recursion is a recursion that calls itself twice

12

Comp 352: Data Structures and Algorithms

Quick Test
Can you think of an example for

Linear Recursion Tail Recursion Binary Recursion

13

Comp 352: Data Structures and Algorithms

Exercice 1
Write a recursive function that prints the digits of a non-negative integer number vertically

14

Comp 352: Data Structures and Algorithms

Solution 1
void recursive_write_vertical(int number) { if (number < 10) // stop condition // Write the only digit, and stop recursion System.out.println(number); else // recursive calls { // Print all digits except the last digit recursive_write_vertical(number/10); // Print the last digit System.out.println(number % 10); } }

15

Comp 352: Data Structures and Algorithms

Exercise 2
Instead of printing only non-negative integers, print any integer number vertically (i.e., including negative numbers)

Hint:

You can have more than one recursive calls or stopping conditions in your recursive function
Comp 352: Data Structures and Algorithms

16

Solution 2
void super_write_vertical(int number) // If number is negative, then a negative sign appears on the top. { if (number < 0) { System.out.println(-); // print a negative sign super_write_vertical(abs(number)); // abs computes the absolute value } else if (number < 10) { System.out.println(number); // Write the one digit } else { super_write_vertical(number/10); // Write all but the last digit System.out.println(number % 10); // Write the last digit

17

} }

Comp 352: Data Structures and Algorithms

Exercise 3
Write a recursive function that counts the number of zero digits in an integer Example: zeros(10200) returns 3

18

Comp 352: Data Structures and Algorithms

Solution 3
int zeros(int numb) { if(numb==0) return 1; else if(numb < 10 && numb > -10) return 0; else // > 1 digits: recursion return zeros(numb/10) + zeros(numb%10); }

19

zeros(10200) zeros(1020) + zeros(0) zeros(102) + zeros(0) + zeros(0) zeros(10) + zeros(2) + zeros(0) + zeros(0) Comp 352: Data Structures and zeros(1) + zeros(0) + zeros(2) + zeros(0)Algorithms + zeros(0)

Recurrence Relation
A recurrence relation is an equation defining a function f(n) recursively in terms of smaller values of n

Can help to determine the Big-O running time of recursive function

20

Comp 352: Data Structures and Algorithms

Example: Recurrence Relation


The running time of Merge-Sort is: (assuming that n is a power of 2)

T(n) = O(1) T(n) = 2 T(n/2) + O(n)

if n = 1 if n > 1

21

Comp 352: Data Structures and Algorithms

Solving Recurrence Relation - I


To simplify the algebra, we write

n instead of O(n) 1 instead of O(1)

So we have
T(1) = 1 T(n) = 2 T(n/2) + n as the recurrence relation

22

Reference: [10]

Comp 352: Data Structures and Algorithms

Solving Recurrence Relation - II


T(n) = 2 T(n/2) + n = 2 [2 T(n/4) + n/2] + n = 4 T(n/4) + 2n = 4 [2 T(n/8) + n/4] + 2n = 8 T(n/8) + 3n ... = 2k T(n/2k) + k n We know that T(1) = 1 and this is how we could terminate the derivation n/2k = 1 n = 2k k = log2n

23

Reference: [10]

Comp 352: Data Structures and Algorithms

Solving Recurrence Relation - III


... = 2k T(n/2k) + k n = 2log2n T(1) + (log2n) n = 2log2n * 1 + n log2n = n + n log2n = O(n log n) // k = log2n

24

Reference: [10]

Comp 352: Data Structures and Algorithms

Exercise 4
Solve the following recurrence relation: T(N) = T(N/2) + 1 T(1) = 1 You may assume that N is a power of 2.

25

Comp 352: Data Structures and Algorithms

Solution 4
Recurrence Relation: T(N) = T(N/2) + 1; T(1) = 1 T(N) = T(N/2) + 1 = T(N/4) + 1 + 1 = T(N/8) + 1 + 1 + 1 = T(N/2k) + 1 + 1 ++ 1 k times = T(1) + 1 + 1 + + 1 = 1 + log2N

26

log2N times

Comp 352: Data Structures and Algorithms

References
[1] Wikipedia Encyclopedia http://en.wikipedia.org/ [2] Dictionary of Algorithms and Data Structures . National Institute of Standards and Technology. http://www.nist.gov/dads/ [3] M.T. Goodrich, R. Tamassia. Data Structures and Algorithms in Java, 4th edition. John Wiley & Sons, 2006. ISBN 0-471-73884-0. http://java4.datastructures.net/ [4] M.T. Goodrich, R. Tamassia, D. Mount. Data Structures and Algorithms in C++. John Wiley & Sons, 2004. ISBN 0-471-20208-8. http://cpp.datastructures.net/ [5] SparkNotes: Examples of Recursion. http://www.sparknotes.com/cs/recursion/examples/ [6] Basic Math and Recursion. Brooks/Cole Publishing Company , 2000. http://www.cs.ust.hk/~huamin/COMP171/recursion.ppt [7] Walter Savitch, Problem Solving with C++ - The Object of Programming, Chapter 13 Recursion, 4th Edition, Pearson Education Inc., 2003 [8] Andrew Horner, Comp104 notes on Recursion, CS Dept, HKUST. [9] Tao Jiang, Recurrence relations and analysis of recursive algorithms, Lecture notes for UCR CS 141: Intermediate Data Structures and Algorithms. http://www.cs.ucr.edu/~jiang/cs141/recur.pdf [10] Owen L. Astrachan, Big-Oh for Recursive Functions: Recurrence Relations, Duke University, 2003. http://www.cs.duke.edu/~ola/ap/recurrence.html Comp 352: Data Structures and Algorithms

27

Thank you ! See you next time

28

Comp 352: Data Structures and Algorithms