Two Approaches to Algorithms An Example (1) Iteration (2) Recursion

Size: px

Start display at page:

Download "Two Approaches to Algorithms An Example (1) Iteration (2) Recursion"

Amos Hoover
6 years ago
Views:

1 2. Recursion

2 Algorithm Two Approaches to Algorithms (1) Iteration It exploits while-loop, for-loop, repeat-until etc. Classical, conventional, and general approach (2) Recursion Self-function call It exploits the concept of divide-and-conquer Possible to construct an algorithm simply, concisely! An Example /* Iterative version */ int FUNC( int n ) { //STATEMENTS for ( ; n > 1; --n ) //INSTRUCTIONS return result; /* Recursive version */ int FUNC( int n) { //STATEMETS return n * FUNC( n-1 );

3 Example : Factorial Number (1) Factorial Number (n!): Mathematical Expression (1) Iteration (2) Recursion Ex) n=3 1 if n 0 Factorial( n) n ( n 1) ( n 2) 2 1 if n 0 1 if n 0 Factorial( n) n Factorial( n 1) if n 0

4 Example : Factorial Number (3) Factorial Number (n!): Programming Expression (1) Iteration int Factorial (int n) { i = 1; result = 1; while (i <= n) { result = result * i; i++; return (result); (2) Recursion int Factorial (int n) { if ( n == 0 ) return(1); else return (n * Factorial (n - 1));

More Examples : Recursion What S(n) computes? S(1) = 2 (i.e., n = 1) S(n) = 2 S(n 1) for n > 1 What T(n) computes? T(1)=0, T(2) = 1 (i.e., n = 1 or 2) T(n) = T(n/2) + 1 for n > 1 S(10) = 2*S(9) = 2*{2*S(8) = 2*{2*{2* *S(1) = 2 10 T(16) = T(8)+1 ={T(4)+1+1 ={{T(2)+1+1+1 = 4 = log16 What FUN(m, n) computes?

5 More Examples : Recursion What S(n) computes? S(1) = 2 (i.e., n = 1) S(n) = 2 S(n 1) for n > 1 What T(n) computes? T(1)=0, T(2) = 1 (i.e., n = 1 or 2) T(n) = T(n/2) + 1 for n > 1 S(10) = 2*S(9) = 2*{2*S(8) = 2*{2*{2* *S(1) = 2 10 T(16) = T(8)+1 ={T(4)+1+1 ={{T(2) = 4 = log16 What FUN(m, n) computes? int FUN (int m, int n) { if (n == 1) return (m); else return (FUN (m, n 1) + m); FUN(3,4)=?

6 Designing Recursion Rules for Designing a Recursion 1. Base case Trivial case Usually, n = 0 or n = 1 Need to terminate an algorithm 2. General case (= Recursive step) Break down the problem into sub-problems characteristics, but smaller size. Usually, n > 0 or n > 1 which are the same 3. Combine the base case and the general case.

x % y) (3) Combine Recursive Algorithm int GCD (int x, int y) { if (y == 0) return (x); else

7 Exercise 1 : Greatest Common Divisors What is GCD of Two Numbers x and y? (1) Base Case : When y = 0, GCD(x, y) =? x (2) General Case : Otherwise, GCD(x, y) = GCD(y,? x % y) (3) Combine Recursive Algorithm int GCD (int x, int y) { if (y == 0) return (x); else return GCD (y, x % y); Iterative Version GCD (int X, int Y) { int R; while (Y > 0) { R = X % Y; X = Y; Y = R; return (X);

8 Exercise 2 : Fibonacci Numbers Fibonacci Numbers: - Each number is the sum of previous two numbers. - Initially, the first two numbers given by 0 and 1; 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, What is n th Fibonacci number? (1) Base Case : When n = 0 or 1, FIB(n) =? n (2) General Case : When n > 1, FIB(n) =? FIB(n 1) + FIB(n 2) (3) Combine int FIB (int n) if ( n == 0 ) return (0); else if (n == 1) return (1); else return (FIB(n - 1) + FIB(n - 2));

9 Exercise 3 : Binary Search (1) Find an Integer X among n ( >1 ) Integers. Use Binary search algorithm (based on recursion) Integers are sorted in ascending order and stored in array list[] mid, left, right are variables indicating the mid, left, and right position in list[] 1. Base Case : Termination condition (1) When X is found:??? list (2) When X is not found:??? front part rear part n 1 4 X <X X=X 2. General Case : Break down list into smaller ones (1) if X exists in the front part (i.e., list[mid] > X) :??? (2) if X exists in the rear part (i.e., list [mid] < X) :??? 6>X

10 Exercise 3 : Binary Search (2) int Bin-Search (list [ ], X, left, right) int mid; If (left <= right) { mid = (left + right) / 2; if (X < list [mid]) Bin-Search (list [], X, left, mid-1); else if (X == list [mid]) else return (mid); list Bin-Search (list [], X, mid+1, right); front part n 1 4 X left front part rear part list(mid)=6 > X rear part list 1 4 X left list(mid) =4 < X right list 1 4 X right list(mid) left right =X

11 When do we need a recursion? We suggest: Do not use a recursion if the answer of the following questions is NO! 1. Is the algorithm or data structure naturally suited to recursion? Ex) binary search, merge sort 2. Is the recursive solution shorter and more understandable? Ex) binary tree traversal, tower of hanoi 3. Does the recursive solution run within acceptable time and space limits? Iterative? Recursive O(nlogn) O(n 2 )

12 Bad use of Recursion (1) Fibonacci Number int FIB(int n) if ( n == 0 ) return (0) else if (n == 1) return (1) else return (FIB(n 1) + FIB(n 2)); This function performs redundant computations by function call; i.e., call FIB(n-2) two times, FIB(n-3) three times, etc. FIB(n) FIB(n-1) FIB(n-2) FIB(n-3) FIB(n-2) FIB(n-3) FIB(n-3) FIB(n-4) FIB(n-4)

13 Bad use of Recursion (2) The number of function calls of recursive Fibonacci is Exponential; Ex) when n = 40, total calls = 3.3 * 10 8, but we need actually only 39 additions #calls 3.3* #additions 40 n Reference from Data Structures by Gilberg and Forouzan

Advantages Recursion : Pros and Cons Simple, concise, and clear in the program

and readability of program improves Disadvantages Computing efficiency may

Overhead int GCD (int x, int y) { if (y == 0) return (x); else return GCD (y,

14 Advantages Recursion : Pros and Cons Simple, concise, and clear in the program coding Not need to know how to actually operate the program The understanding and readability of program improves Disadvantages Computing efficiency may decrease due to repetitive operations that bring forth Space Overhead Time Overhead int GCD (int x, int y) { if (y == 0) return (x); else return GCD (y, x % y); GCD (int X, int Y) { int R; while (Y > 0) { R = X % Y; X = Y; Y = R; return (X);

15 Recursion Can be Inefficient! (1) When Program A calls Program B, it needs to store the flowing data (information): The parameter values that Program A used The local variable values that Program A used Return values Program A int *a, b func(x, y) Program B int *a, b funt(x,y) Return address of the command that carries out in coming back to Program A. The above data are stored in memory, named as stack frame (also known as activation record ) Since recursion is a sort of self-calling program, multiple copies of the program are created; thus, inefficient in terms of space and time performance.

16 Recursion Can be Inefficient! (2) Which one is More Efficient in computing n!? Does each version use a single memory space or a number of memory spaces in terms of parameter n? Iterative version int factorial (int n) { i = 1; result = 1; while (i <= n) { result = result * i; i++; return (result); Recursive version int Factorial (int n) { if ( n == 0 ) return(1); else return (n * Factorial (n - 1)); Single or Multiple memory spaces?

17 Return Recursion Can be Inefficient! (3) Parameters Local variables Return Adress Parameters Local variables Return Adress Parameters Local variables Return Adress Call return return return Int factorial(n) { if (n == 0 ) return 1; else return (n * factorial(n-1) ); Int factorial(n-1) { if (n == 0 ) return 1; else return (n-1 * factorial(n-2)); Int factorial(n-2) { if (n == 0 ) return 1; else return (n-2 * factorial(n-3) ); call call call

Standard Version of Starting Out with C++, 4th Edition. Chapter 19 Recursion. Copyright 2003 Scott/Jones Publishing

Standard Version of Starting Out with C++, 4th Edition Chapter 19 Recursion Copyright 2003 Scott/Jones Publishing Topics 19.1 Introduction to Recursion 19.2 The Recursive Factorial Function 19.3 The Recursive