1 / 26

# Cs212: DataStructures - PowerPoint PPT Presentation

Cs212: DataStructures. Lecture 4: Recursion. Lecture Contents. The Concept of Recursion Why recursion ? Factorial – A case study Content of a Recursive Method Recursion vs. iteration. The Concept of Recursion.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about ' Cs212: DataStructures' - overton

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

### Cs212: DataStructures

Lecture 4: Recursion

• The Concept of Recursion

• Why recursion?

• Factorial – A case study

• Content of a Recursive Method

• Recursion vs. iteration

The Concept of Recursion

• repetition can be achieved by writing loops, such as for loops and while loops.

• Another way to achieve repetition is through recursion, which occurs when a function calls itself.

• A recursive function is a function that calls itself , either directly or indirectly ( through another function).

• For example :

void myFunction( int counter)

{if(counter == 0)     return;else       {myFunction(--counter);       return;}

}

• Sometimes, the best way to solve a problem is by solving a smaller version of the exact same problem first

• Recursion is a technique that solves a problem by solving a smaller problem of the same type

• Allows very simple programs for very complex problems

3*2*1

=

6

Factorial – A case study

• Factorial definition: the factorial of a number is product of the integral values from 1 to the number.

factorial 3

product [4..1]

=

product [4,3,2,1]

=

4*3*2*1

=

24

Factorial – A case study

• Iteration algorithm definition (non-recursive)

1 if n = 0

Factorial(n) =

n*(n-1)*(n-2)*…*3*2*1 if n > 0

factorial 4

3 * factorial 2

=

3 * (2 * factorial 1)

=

3 * (2 * (1 * factorial 0))

=

3 * (2 * (1 * 1))

=

3 * (2 * 1)

=

3 * 2

=

6

Factorial – A case study

7

• Recursion algorithm definition

1 if n = 0

Factorial(n) =

n * ( Factorial(n-1) ) if n > 0

factorial 3

Content of a Recursive Method

• Base case(s).

• One or more stopping conditions that can be directly evaluated for certain arguments

• there should be at least one base case.

• Recursive calls.

• One or more recursive steps, in which a current value of the method can be computed by repeated calling of the method with arguments (general case).

• The recursive procedure call must use a different argument that the original one: otherwise the procedure would always get into an infinite loop…

void myFunction( int counter){if( counter == 0)…........else

{………myFunction(--counter);

}}

Use an if-else statement to distinguish between a Base case and a recursive step

Iterative factorialalgorithm

Recursive factorialAlgorithm

public static intrecursiveFactoria(intn) {

if (n == 0)

return 1; // base case

else

return n *recursiveFactorial(n-1): // recursive case

}

public static intrecursiveFactoria(int n) {

i = 1

factN= 1

for(int i=1; i<= n; i++)

factN= factN * i

i = i + 1

return factN

}

recursive implementation of the factorial function is somewhat simpler than the iterative version in this case there is no compelling reason for preferring recursion over iteration.

For some problems, however, a recursive implementation can be significantly simpler and easier to understand than an iterative implementation.

• Each recursive call is made with a new arguments Previous calls are suspended

• Each entry of the trace corresponds to a recursive call.

• Each new recursive function call is indicated by an arrow to the newly called function.

• When the function returns, an arrow showing this return is drawn and the return value may be indicated with this arrow.

• Iteration can be used in place of recursion

• An iterative algorithm uses a looping construct

• A recursive algorithm uses a branching structure(if-statement)

• Recursive solutions are often less efficient, in terms of both time and space, than iterative solutions

• Recursion can simplify the solution of a problem, often resulting in shorter, more easily understood source code

1 Linear Recursion

• The simplest form of recursion is linear recursion, where a method is defined so that it makes at most one recursive call each time it is invoked.

Summing the Elements of an Array Recursively

A =

Algorithm LinearSum(A , n )

input

A integer array Aand an integer n>=1, such that A has at least n elements

output

The sum of the first n integers in A

if (n = 1) then

return A[0]

else

return LinearSum(A, n - 1) + A[n - 1]

n = 5

Algorithm sum ( n <integer>)

Input

n is an integer number

o

is returned

if (n == 1)

return 1;

else

return n + sum(n-1);

End IF

Summation (Sigma) Notation con..

• For n =3

Sum (3)

return 3+Sum(2)

return 3+3

return 6

Sum(2)

return 2+ sum(1)

return 2+1

return 3

return 1

Sum(1)

return 1

Printing “Hello World” n Times Using Recursion

Algorithm printHelloWorld( n <integer>)

Input

n is an integer number

Output

“Hello World” printed n times

If ( n >0 )

{

Print “Hello World”

printHelloWorld( n – 1 );

}

Printing “Hello World” n Times Using Recursion

hello world

return

printHelloWorld(3)

Print hello world

printHelloWorld(2)

hello world

printHelloWorld(2)

Print hello world

printHelloWorld(1)

return

hello world

printHelloWorld(1)

Print hello world

printHelloWorld(0)

return

return

• printHelloWorld(0)

2 Binary Recursion

• When an algorithm makes two recursive calls, we say that it uses binary recursion. These calls can, for example, be used to solve two similar halves of some problem,

• Let us consider the problem of computing the kth Fibonacci number.

• {0, 1, 1, 2, 3, 5, 8, 13, 21, 34,….}

• Fibonacci numbers are recursively defined as follows:

• F0 = 1

• F1 = 1

• Fi = Fi−1 + Fi−2.

Computing Fibonacci Numbers con..

Algorithm BinaryFib(k):

Input:

Nonnegative integer k

Output:

The kth Fibonacci number f

if(k< I) thenreturn k

elsereturn BinaryFib(k - 1) + BinaryFib(k -2)

Calculate BinaryFib(3)

what is the output of fun(16)?

Algorithm fun(int X)

if ( x <=4 )

return 1

else

return fun(x/4) + fun (x/2)

Result = 3

3 Multiple Recursion

• Generalizing from binary recursion, we use multiple recursion when a method may make multiple recursive calls, with that number potentially being more than two.