COMP90038 Algorithms and Complexity: Recursion

COMP90038 Algorithms and Complexity
Recursion
Michael Kirley
Lecture 6
Semester 1, 2017
Algorithms and Complexity (2017) Recursion 1 / 13

Recursion
We have already seen a few examples of recursion. Now let us cover

recursion in some more detail.
Recursion is a very natural approach when we have to process data

structures that are defined recursively, such as trees.
But there are also examples of, say, array-processing algorithms that
are naturally recursive.
Next week we shall express depth-first graph traversal recursively

(that’s the natural way), and later we’ll meet other examples of
recursion.

Example: Factorial Numbers
To compute n!, we can use recursion (left algorithm) or iteration

(right algorithm):
function Fac(n) function Fac(n)

if n = 0 then result ← 1
return 1 while n > 0 do
return Fac(n − 1) ∗ n result ← result ∗ n
n←n−1
return result
Here the iterative solution would normally be preferred.

Example: Fibonacci Numbers
To generate the nth number of sequence 1 1 2 3 5 8 13 21 34 55 . . .
function Fib(n)
if n = 0 then
return 1
if n = 1 then
return 1
return Fib(n − 1) + Fib(n − 2)
This algorithm follows the definition of Fibonacci numbers closely, so

it is very easy to understand.
Unfortunately it performs a lot of redundant computation. Why?
In fact, this algorithm is exponential in n. ✎

Fibonacci Again
The following solution makes use of the fact that we only ever need
to remember the two latest numbers in the sequence (recursive
version on the left, iterative on the right).
function Fib(n, a, b) function Fib(n)
if n = 0 then a←1
return a b←0
return Fib(n − 1, a + b, a) while n > 0 do
a←a+b
b ← a−b
Initial call: Fib(n, 1, 0) n←n−1
return a
In either case, we have a simple, linear-time solution.
(There is a cleverer, still recursive, way which is O(log n).)

The Tower of Hanoi
Assume n disks need to be moved from peg init to peg fin.
Of course we can only move some top-most disk to the top of some
pile. Nevertheless the solutions is conveniently expressed recursively,
saying how to solve the task for n desks, assuming we first solve the
problem for n − 1:
function Hanoi(n, init, aux, fin)

if n > 0 then
Hanoi(n − 1, init, fin, aux)
Move one disk from init to fin
Hanoi(n − 1, aux, init, fin)
This is an elegant formulation which relieves of us the headache of

deciding which peg to target in the first move.
A Challenge: The Coin Change Problem
There are six different kinds of Australian coin.
In cents, their values are: 5, 10, 20, 50, 100, 200.
In how many different ways can I produce a handful of coins adding

up to $4?
This is not an easy problem!
A key to solving it is to find a way of breaking it down to simpler

sub-problems.

Recursion as a Problem Solving Technique
The number of ways to make $4 is:
the number of ways to make $2

plus
the number of ways to make $4 using 5, 10, 20, 50, 100 only
The reason is that a given $4 handful either makes use of a $2 coin

(200) or it does not.
Now we have two sub-problems to solve, but each is smaller than the
original problem!

The Recursive Case
The number of ways to make $4 is 2728:
the number of ways to make $2: 293

plus
the number of ways to make $4 using 5, 10, 20, 50, 100 only: 2435
We will express this as an algorithm shortly.
But what are the base cases?
Usually that’s the easy part, but here they are harder to determine
than what the recursive case looks like!

The Base Cases
If we are asked to produce coins for the amount 0 then we can do

that, in exactly one way: by using none of the allowed coins. At the
end of a chain of recursive calls, this situation indicates that we
found a successful combination of coins.
If we are asked to produce a negative amount then we must

renege—it can be done in zero ways.
If we are asked to produce a positive amount, but none of the six

kinds of coins are allowed to be used, then again that is not
possible—it can be done in zero ways.

The Recursive Algorithm
function Ways(amount, denominations)

if amount = 0 then
return 1
if amount < 0 then
return 0
if denominations = ∅ then
return 0
d ← selectFrom(denominations)
return Ways(amount − d , denominations) +
Ways(amount, denominations \ {d })
Initial call: Ways(amount, {5, 10, 20, 50, 100, 200}).

The Recursive Solution and Complexity
Although our recursive algorithm is short and elegant, it is not the

most efficient way of solving the problem.
Its running time grows exponentially as you grow the input amount.
More efficient solutions can be developed using memoing or dynamic

programming—more about that later.

Coming Soon to a Theatre Near You
Graphs, trees, graph traversal and allied algorithms.

COMP90038 Algorithms and Complexity: Recursion

Uploaded by

Copyright:

Available Formats

COMP90038 Algorithms and Complexity: Recursion

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

COMP90038 Algorithms and Complexity: Recursion

Uploaded by

Copyright:

Available Formats

COMP90038 Algorithms and Complexity

Algorithms and Complexity (2017) Recursion 1 / 13

We have already seen a few examples of recursion. Now let us cover

Recursion is a very natural approach when we have to process data

Next week we shall express depth-first graph traversal recursively

Algorithms and Complexity (2017) Recursion 2 / 13

To compute n!, we can use recursion (left algorithm) or iteration

function Fac(n) function Fac(n)

Here the iterative solution would normally be preferred.

Algorithms and Complexity (2017) Recursion 3 / 13

This algorithm follows the definition of Fibonacci numbers closely, so

Unfortunately it performs a lot of redundant computation. Why?

In fact, this algorithm is exponential in n. ✎

(There is a cleverer, still recursive, way which is O(log n).)

function Hanoi(n, init, aux, fin)

This is an elegant formulation which relieves of us the headache of

There are six different kinds of Australian coin.

In cents, their values are: 5, 10, 20, 50, 100, 200.

In how many different ways can I produce a handful of coins adding

This is not an easy problem!

A key to solving it is to find a way of breaking it down to simpler

Algorithms and Complexity (2017) Recursion 7 / 13

The number of ways to make $4 is:

the number of ways to make $2

The reason is that a given $4 handful either makes use of a $2 coin

Algorithms and Complexity (2017) Recursion 8 / 13

The number of ways to make $4 is 2728:

the number of ways to make $2: 293

We will express this as an algorithm shortly.

But what are the base cases?

Algorithms and Complexity (2017) Recursion 9 / 13

If we are asked to produce coins for the amount 0 then we can do

If we are asked to produce a negative amount then we must

If we are asked to produce a positive amount, but none of the six

Algorithms and Complexity (2017) Recursion 10 / 13

function Ways(amount, denominations)

Initial call: Ways(amount, {5, 10, 20, 50, 100, 200}).

Algorithms and Complexity (2017) Recursion 11 / 13

Although our recursive algorithm is short and elegant, it is not the

More efficient solutions can be developed using memoing or dynamic

Algorithms and Complexity (2017) Recursion 12 / 13

Graphs, trees, graph traversal and allied algorithms.

Algorithms and Complexity (2017) Recursion 13 / 13

You might also like