Lecture 17 23/10/2003 Recursion

Applied Algorithms
(Lecture 17)
Recursion
Fall-23

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Recursion
• Basic problem solving technique is to
divide a problem into smaller subproblems
• These subproblems may also be further
divided into much 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

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

What is recursion?
• A procedure that is defined in terms of
itself
• In a computer language a function that
calls itself

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Recursion

A recursive definition is one which is defined in terms of itself.

Examples:

• A phrase is a "palindrome" if the 1st and last letters are the same,
and what's inside is itself a palindrome (or empty or a single letter)

• rotor

• rotator

• 12344321

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Recursion

• The definition of the natural numbers:

1 is a natural number
N=
if n is a natural number, then n+1 is a natural number

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Recursion in Computer Science

1. Recursive data structure: A data structure that is partially
composed of smaller or simpler instances of the same data
structure. For instance, a tree is composed of smaller trees
(subtrees) and leaf nodes, and a list may have other lists as
elements.
a data structure may contain a pointer to a variable of the same
type:
struct Node {
int data;
Node *next;
};

2. Recursive procedure: a procedure that invokes itself

3. Recursive definitions: if A and B are postfix expressions, then A
B + is a postfix expression.
National University Of Computer & Emerging Sciences
Lecture 17 23/10/2003 Recursion

Recursive Data Structures

Linked lists and trees are recursive data structures:

struct Node {
int data;
Node *next;
};

struct TreeNode {
int data;
TreeNode *left;
TreeNode * right;
};

Recursive data structures suggest recursive algorithms.

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

A mathematical look
• We are familiar with
f(x) = 3x+5
• How about
f(x) = 3x+5 if x > 10 or
f(x) = f(x+2) -3 otherwise

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Calculate f(5)
f(x) = 3x+5 if x > 10 or
f(x) = f(x+2) -3 otherwise
• f(5) = f(7)-3
• f(7) = f(9)-3
• f(9) = f(11)-3
• f(11) = 3(11)+5
= 38
But we have not determined what f(5) is yet!

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Calculate f(5)
f(x) = 3x+5 if x > 10 or
f(x) = f(x+2) -3 otherwise
• f(5) = f(7)-3 = 29
• f(7) = f(9)-3 = 32
• f(9) = f(11)-3 = 35
• f(11) = 3(11)+5
= 38
Working backwards we see that f(5)=29

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Series of calls

f(5)

f(7)

f(9)

f(11)

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

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

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Recursive Definition
of the Factorial Function

1, if n = 0
n! =
n * (n-1)! if n > 0

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

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Recursive Definition
of the Fibonacci Numbers

The Fibonacci numbers are a series of numbers as follows:

fib(1) = 1
fib(2) = 1
1, n <= 2
fib(3) = 2 fib(n) = fib(n-1) + fib(n-2), n > 2
fib(4) = 3
fib(5) = 5
...
fib(3) = 1 + 1 = 2
fib(4) = 2 + 1 = 3
fib(5) = 2 + 3 = 5

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

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:

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

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.
National University Of Computer & Emerging Sciences
Lecture 17 23/10/2003 Recursion

Recursion for efficient programming

As a preliminary exercise, try to program the following sequence...

111,112,113,121,122,123,131,132,133,
211,212,213,221,222,223,231,232,233,
311,312,313,321,322,323,331,332,333. ...using For loops.

Answer: It's as simple as:-

for i = 1 to 3
for j = 1 to 3
for k = 1 to 3 print i, j, k

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Recursion for efficient programming

void Func(n)
{
for i = 1 to 3
{
A[n] = i
if (n < 3)
Func(n+1)
else
print A[1], A[2], A[3]
}
}
A[] is simply an array of integers. The function should be invoked
with initial n value as 1, i.e., Func(1). Trace the program to figure
out the output.
National University Of Computer & Emerging Sciences
Lecture 17 23/10/2003 Recursion

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Towards an Efficient Approach

• To improve efficiency, we write the entire algorithm to output
the first m terms in a recursive way, rather than use recursion
in just the subroutine

• The key to using a recursive approach to solving a problem is

to work out how to solve the problem, assuming that a simpler
case of the same problem has already been solved.
• So, for our sequence problem, we need to work out how to
output the first m terms, assuming that we already have an
algorithm to output the first m - 1 terms.

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Towards an Efficient Approach

• This can be done in the following way:

1. Using the algorithm we already have, output the first m - 1 terms-omit

this step if m = 1
2. Evaluate t(m), the mth term of the sequence
3. Output the value of t(m)

• Before converting this approach to pseudo code, look at how step 2

is to be achieved.

• It's silly to use the recursive function algorithm to evaluate t(m), since
this would cause precisely the type of inefficiency we're trying to
eliminate.

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Counting Digits
• Recursive definition
digits(n) = 1 if (–9 <= n <= 9)
1 + digits(n/10) otherwise
• Example
digits(321) =
1 + digits(321/10) = 1 +digits(32) =
1 + [1 + digits(32/10)] = 1 + [1 + digits(3)] =
1 + [1 + (1)] =
3

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Counting Digits in C++

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

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Recursion
• If you want to compute f(x) but can’t
compute it directly
• Assume you can compute f(y) for any
value of y smaller than x
• Use f(y) to compute f(x)
• For this to work, there has to be at least
one value of x for which f(x) can be
computed directly (e.g. these are called
base cases)

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Evaluating Exponents Recurisivley

int power(int k, int n) {

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

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

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
National University Of Computer & Emerging Sciences
Lecture 17 23/10/2003 Recursion

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;
}
National University Of Computer & Emerging Sciences
Lecture 17 23/10/2003 Recursion

Selection Sort
void selectionSort
(double[] A, int lo, int hi)
{
// A[0]..A[lo-1] contain smallest
// values in A, in ascending order
if (lo < hi) {
swap(A, lo, findMiniumum(A, lo, hi);
selectionSort(A, lo + 1, hi);
}
}

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Stacks
• Every recursive function can be
implemented using a stack and iteration.
• Every iterative function which uses a stack
can be implemented using recursion.

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Disadvantages
• May run slower.
– Compilers
– Inefficient Code

• May use more space.

National University Of Computer & Emerging Sciences

Lecture 17 23/10/2003 Recursion

Advantages
• More natural.
• Easier to prove correct.
• Easier to analysis.
• More flexible.

National University Of Computer & Emerging Sciences