Recursion

• What is Recursion?
• Recursive data structures
• Recursive data algorithms

Programming and Data Structures 1

 What is Recursion
• The programs we have been doing to date have been organised into functions
that call another function in a disciplined, hierarchical way.

• A function is said to be recursive if it calls itself either directly or indirectly

through another function.

• A recursive function knows when to stop calling itself once a base case is
reached.
e.g. //print numbers 1 to n backwards
int print(int n)
{
if ( n = = 0) // this is the terminating base case
return 0;
else {
System.out.print(“”+n+” “);
return print(n-1); // recursive call to itself again
}
}

Programming and Data Structures 2

 The Recursion Step
• A recursive method tackles a problem by launching (calling) a copy of itself to work
on a smaller problem.

• This is called the recursion step

• The recursion step can result in many more such recursive calls as the method keeps
dividing each problem it is called with into two smaller problems.

• It is important to ensure that the recursion terminates.

• Each time the function calls itself with a slightly simpler version of the original problem.

• This sequence of smaller problems must eventually converge on the base case.

Programming and Data Structures 3

 Using Recursion Properly
• To use recursion properly we need to remember to provide two parts:

1. One (or more) base cases that are not recursive, i.e. we can
directly give a solution:
if (n==0)
return 0;

2. One (or more) recursive cases that operate on smaller

problems that get closer to the base case(s)

return print(n-1);

• NOTE: - The base case(s) should always be checked before the recursive calls.
- Most of the time, a recursive function will usually return something.

Programming and Data Structures 4

 Infinite Recursion
• Be very Careful! We must make sure that recursion eventually
stops, otherwise it will run forever (well not forever… until we
run out of memory)

e.g.
// example of a badly defined recursive function
int Bad_recursion(n)
{
int x = Bad_recursion(n-1); // Bad!!!
if (n == 1)
return 1;
else
return n*x;
}

Programming and Data Structures 5

 Recursion & Memory
• Each recursive call makes a new copy of that method (actually only the variables) in
memory

• Once a method ends (i.e. returns some data), the copy of that returning method is
removed from memory

• In our previous example, if we called the print function with n=4, visually our memory
assignments may look like such :
Original calling method

print(4)

print(3)

returns 0 print(2)

returns 0 print(1)

returns 0 print(0)
Returns 0 to main calling program
returns 0

Programming and Data Structures 6

 Recursive Algorithms
• Recursive Algorithm : A solution that uses recursion to solve the problem

• As mentioned previously, methods are said to be recursive if they call

themselves either directly or indirectly.

• Many problems can be solved and best described through recursive

algorithms (e.g. traversal of nodes in a binary tree)

• Some problems are best suited for recursive solutions while others are not.

• Recursion is a complex topic and recursive algorithms can get quite complex.

• We are going to look at some simple problems that can be solved recursively.

Programming and Data Structures 7

 Solving Factorials
• Factorial Explanation :
- The product of the positive integers from 1 to n inclusive is called
“n factorial”, usually denoted by n!

n! = n*(n-1)*(n-2)…3*2*1

• Mathematical explanation :

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

• Example :
6! = 6*5*4*3*2*1 = 720

Programming and Data Structures 8

 Solving Factorials – Using iteration
• We can write an iterative solution to the factorial problem :

Pseudo-Code Actual Code

Begin int factorial (int n)
factorial(n) {
result = 1; //init result – i.e. n = 0 or 1 int result = 1; //init result – i.e. n = 0 or 1
for i = 2 to n // if n is > 1 for(int i = 2; i<= n; i++) // if n is > 1
result = result * i; //fact is n*(n-1)! {
endfor result = result * i; //fact is n*(n-1)!
return result }
endmethod return result
End }

Programming and Data Structures 9

 Solving Factorials – Using Recursion
• We can obtain a recursive definition of the factorial method by observing the relationship from
the previous mathematical explanation :

n! = 1, if n = 0
n * (n-1)! if n > 0
• From this we can obtain both our base and recursive cases:
- Base Case :
if(n <= 1)
return 1;
- Recursive Case:
return n*factorial(n-1);

• Now that we know both our base and recursive cases we can write our factorial method:

int factorial(int n)
{
if (n <=1) // the base case
return 1
else
return n * factorial(n-1); // the recursive case
}

Programming and Data Structures 10

 Visual Example - Factorials
Recursive calls for 4! Values returned from each recursive call

Final result = 24
4! 4!
4*6
24 returned

4 * 3! 4 * 3!

3 * 2!
3*2
6 returned

3 * 2!
2 * 1
2 returned

2 * 1! 2 * 1!
1 returned

1 1
Programming and Data Structures 11
 Recursion Vs. Iteration
• So which way is better? – iteration or recursion?

• Answer is that it depends on what you are trying to do.

• Usually, a recursive approach more naturally mirrors the problem at hand. So,
a recursive approach makes it simpler to tackle a problem which may not have
the most obvious of answers.

• However, recursion carries an overhead that for each recursive call needs space
on the stack frame.

• This extra memory need can be quite processor intensive and consume a lot of
memory if recursion is nested deeply

• Iteration does not have this overhead as it occurs within the method so the
overhead of repeated method calls and extra memory is ommitted.
Programming and Data Structures 12
 Recursion Vs. Iteration - Differences

Recursion Iteration
• terminates when a base case is reached. • Terminates when a condition is proven to be
false.
• Each recursive call requires extra space
• Each iteration does not require any extra space
on the stack frame (i.e. memory).
as it resides in the same method.
• If we get infinite recursion, we will • an infinite loop could potentially loop forever
eventually run out of memory, resulting in since there is no extra memory being created.
a stack overflow.

• solutions to some problems are easier to • Iterative solutions to a problem may not
formulate recursively. always be as obvious as a recursive solution.

Programming and Data Structures 13

Another Example - The Fibonacci Series
• The Fibonacci series :

0, 1, 1, 2, 3, 5, 8, 13, 21, 34 …

begins with a 0 and 1 and has the property that each subsequent Fibonacci number is
the sum of the previous two Fibonnacci numbers

• A Fibonnacci number, fib(n), can be expressed mathematically as :

0 if n = 0
fib(n) = 1, if n = 1
fib(n-1) + fib(n-2), if n > 1

Programming and Data Structures 14

 The Fibonacci Function
• Once again, we can obtain our base and recursive cases by observing the mathematical relationship
as we did before with factorials :

- Base case(s) :
if (n == 0) or (n == 1)
return n;
- Recursive case(s) :
return fib(n-1) + fib(n-2);

• Now we may write the function to obtain a fibonnacci number :

unsigned int fib(unsigned int n)

{
if ((n == 0) || (n == 1)) // the base case
return n;
else
return fib(n-1) + fib(n-2); the recursive case
}

• Note: In order to produce a fibonacci series we would iteratively call this function to produce the
required Fibonacci number in the series

Programming and Data Structures 15

 Visual Example – Fibonacci Series
Example for n = 3

fib(3) Result of 2 is returned to the main calling program

returns fib(2) + fib(1)

returns fib(1) + fib(0) returns 1

returns 1 returns 0

Programming and Data Structures 16

 Fibonacci Series - Caution
• A word of caution is in order about recursive programs like the one we use
here to generate Fibonacci numbers.

• Each level of recursion in the fibonacci function has a doubling effect on the
number of calls.

• Calculating the 20th Fibonacci number would require on the order of about a
million calls.

• Calculating the 30th Fibonacci number would require around a billion calls.

• This is referred to as “exponential complexity”.

• How would you write it iteratively? – Not as intuitive! – Use a bottom up

dynamic programming solution.

Programming and Data Structures 17

 Fibonacci Series – Another Solution
• One possibility to improve our recursive approach is to use arrays in a top-down
approach to remember the intermediate values calculated :

KnownFib[MAXSIZE] = unknown; // initialise all slots to indicate unknown

Fib(x)
if knownFib[x] <> unknown //if fib number x is known
return knownF[x] // return known result

if x < 1 // if fib number x is 0

t = 0; // then return 0
if x = 1 // if fib number x is 1
t = 1; // return 1
if x > 1 // if fib number x is greater than 1
t = fib(x-1) + fib(x-2) // recursively calculate this number

knownF[x] = t // fib number x now known so put into our known array
return knownF[x] // return fib number x

• Note the index of our knownFib array represents each fib number x so that x can be used here as
an index into our knownFib array.

Programming and Data Structures 18

 Classic Recursive Problems
• Here are some classic problems that use recursion to solve:
- Queens Problem
- Knights Problem
- Towers of Hanoi

• Some more complex sorting algorithms require that we use a

recursive approach in order to solve them. Two of these that we
will be looking at later on are :
- MergeSort
- QuickSort

Programming and Data Structures 19