Scribd
Upload
97 views15 pages

Lec 4 Algo Spr15 Recursion

The document discusses recursion, which is a problem-solving technique where a function calls itself to solve smaller instances of the same problem. It provides examples of recursively defined functions, including factorial, Fibonacci numbers, and counting digits. It emphasizes the importance of base cases to eventually stop recursion, and discusses divide and conquer as an approach to make recursive algorithms more efficient.

Uploaded by

ZoHaib Ahmed
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
97 views15 pages

Lec 4 Algo Spr15 Recursion

The document discusses recursion, which is a problem-solving technique where a function calls itself to solve smaller instances of the same problem. It provides examples of recursively defined functions, including factorial, Fibonacci numbers, and counting digits. It emphasizes the importance of base cases to eventually stop recursion, and discusses divide and conquer as an approach to make recursive algorithms more efficient.

Uploaded by

ZoHaib Ahmed
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 15

Design and Analysis of Algorithms

Spring 2015

National University of Computer and Emerging Sciences,


Islamabad

Recursion
Basic problem solving technique is to
divide a problem into smaller subproblems
These subproblems may also be divided
into smaller subproblems
When the subproblems are small enough
to solve directly the process stops
A recursive algorithm is a problem solution
that has been expressed in terms of two or
more easier to solve subproblems

Recursion
Recursion occurs when a function/procedure calls itself.
Many algorithms can be best described in terms of recursion.
Example: Factorial function
The product of the positive integers from 1 to n inclusive is
called "n factorial", usually denoted by n!:
n! = 1 * 2 * 3 .... (n-2) * (n-1) * n

Recursive Definition
of the Factorial Function

n! =

5! = 5 * 4!
4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1!
1! = 1 * 0!

1,
n * (n-1)!

= 5 * 24 = 120
= 4 * 3! = 4 * 6 = 24
= 3 * 2! = 3 * 2 = 6
= 2 * 1! = 2 * 1 = 2
= 1 * 0! = 1

if n = 0
if n > 0

Recursive Definition
of the Fibonacci Numbers
The Fibonacci numbers are a series of numbers as follows:
fib(1) = 1
fib(2) = 1
fib(3) = 2
fib(4) = 3
fib(5) = 5
...

fib(n) =

1,
n <= 2
fib(n-1) + fib(n-2), n > 2

fib(3) = 1 + 1 = 2
fib(4) = 2 + 1 = 3
fib(5) = 2 + 3 = 5

Recursive Definition

int BadFactorial(n){
int x = BadFactorial(n-1);
if (n == 1)
return 1;
else
return n*x;
}

What is the value of BadFactorial(2)?


We must make sure that recursion eventually stops, otherwise
it runs forever:

Using Recursion Properly


For correct recursion we need two parts:
1. One (ore more) base cases that are not recursive, i.e. we
can directly give a solution:
if (n==1)
return 1;
2. One (or more) recursive cases that operate on smaller
problems that get closer to the base case(s)
return n * factorial(n-1);
The base case(s) should always be checked before the recursive
calls.

Counting Digits
Recursive definition
digits(n) = 1
1 + digits(n/10)

if (9 <= n <= 9)
otherwise

Example
digits(321) =
1 + digits(321/10) = 1 +digits(32) =
1 + [1 + digits(32/10)] = 1 + [1 + digits(3)] =
1 + [1 + (1)] =
3

Counting Digits in C++


int numberofDigits(int n) {
if ((-10 < n) && (n < 10))
return 1;
else
return 1 +
numberofDigits(n/10);
}

Evaluating Exponents Recursively


int power(int k, int n) {
// raise k to the power n
if (n == 0)
return 1;
else
return k * power(k, n 1);
}

Divide and Conquer


Using this method each recursive
subproblem is about one-half the size of
the original problem
If we could define power so that each
subproblem was based on computing kn/2
instead of kn 1 we could use the divide and
conquer principle
Recursive divide and conquer algorithms
are often more efficient than iterative
algorithms

Evaluating Exponents Using Divide


and Conquer
int power(int k, int n) {
// raise k to the power n
if (n == 0)
return 1;
else{
int t = power(k, n/2);
if ((n % 2) == 0)
return t * t;
else
return k * t * t;
}

Disadvantages
May run slower.
Compilers
Inefficient Code

May use more space.

Advantages

More natural.
Easier to prove correct.
Easier to analyze.
More flexible.

Reference
Introduction to Algorithms
Chapter # 4
Thomas H. Cormen
3rd Edition

You might also like