Recursion
Minh Ngo
1 Definitions
Definition 1. Reduction is a technique to reduce a problem X to a problem Y that we already have an algorithm
to solve.
Definition 2. Recursion is a kind of reduction, which can be described as:
• If the given instance of the problem can be solved directly, solve it directly.
• Otherwise, reduce it to one or more simpler instance(s) of the same problem. This is analogous to induction
hypothesis in mathematics.
Definition 3. A function which calls itself directly or indirectly is a recursive function .
In a recursive program, the solution to the base case is provided and the solution of the bigger problem is
expressed in terms of smaller problems. A typical recursive algorithm can be expressed in pseudocode as following:
Algorithm 1 Recursion
1: procedure Recursion (case)
2: if Base case then
3: return solution of base case
4: else
5: return Recursion(subcase(s))
6: end if
7: end procedure
2 Examples
2.1 Peasant multiplication
Peasant multiplication algorithm is based on the following simple identity:
0
if x=0
x · y = 2 · bx/2c · y if x is even
2 · bx/2c · y + y x is odd
if
So we can multiply x and y by multiplying x0 and y 0 , then may be add y to the result (if x is odd). This
multiplication is simpler since x0 < x, and if we keep decreasing x, we will eventually get to 0. We can express the
process algorithmically as follow.
1
Algorithm 2 Peasant multiplication
1: procedure Multiply x, y ( )
2: if x=0 then
3: return 0
4: else
5: prod ← 2 · Multiply(bx/2c, y) . Recurse
6: if x is odd then
7: prod ← prod + y
8: end if
9: return prod
10: end if
11: end procedure
An implementation of the above algorithm in C.
# include < stdio .h >
int multiply ( int x , int y) {
if (x == 0) return 0;
int prod = 2 * multiply (x / 2, y) ;
if (x & 1) return prod + y ;
return prod ;
}
int main () {
printf ("%d \n" , multiply (6 , 5) );
}
An implementation of the above algorithm in Python.
def multiply (x , y):
if x == 0: return 0
prod = 2 * multiply ( x // 2, y)
if x & 1: return prod + y
return prod
print ( multiply (6 , 5) )
2.2 Calculate power
When we replace the addition with the multiplication and the multiplication with the power in the multiply
algorithm above, we will receive a recursive algorithm to calculate power.
The identity for power is similar:
1
2
if y=0
y
x = xby/2c if y>0 and y even
by/2c 2
x ·x if y>0 and y odd
y
So we can calculate x by taking the power y/2 of x, then take it square and may be multiply y. This problem
is simpler, and if we keep decreasing y, we will get to base case y = 0. Algorithmically, the identity looks like this.
Algorithm 3 Binary power
1: procedure Power x, y( )
2: if y=0 then
3: return 1
4: else
5: pow ← Power(x, by/2c) . Recurse
6: if y is odd then
7: pow ← pow · x
8: end if
9: return pow
10: end if
11: end procedure
2
An implementation of the above algorithm in C.
# include < stdio .h >
long long power ( int x , int y ) {
if (y == 0) return 1;
long long pow = power (x , y / 2) ;
if (y & 1) return pow * pow * 1 ll * x;
else return pow * pow ;
}
int main () {
printf ("% lld \n " , power (6 , 5) ) ;
}
An implementation of the above algorithm in Python.
def power (x , y):
if y == 0: return 1
pwr = power (x , y // 2)
if y & 1: return pow ** 2 * x
return pow ** 2
print ( pow (6 , 5) )
2.3 Calculate factorial
The algorithm for factorial makes use of this simple identity
n! = (n − 1)! · n
So to calculate n!, we just need to calculate (n−1)! and the multiply the result with n. And when we keep decreasing
n, we will eventually reach base case 0! = 1.
Algorithm 4 Calculate factorial
1: procedure Fact x ( )
2: if x=0 then
3: return 1
4: else
5: return x· Fact (x − 1) . Recurse
6: end if
7: end procedure
An implementation of the above algorithm in C. Note that in C, we can only calculate small factorial using
built-in data type. If we want to calculate large factorial, we have to use Python or write an ad hoc multiplication
of a large number and a small number, which we will discuss in a different note.
# include < stdio .h >
long long fact ( int x) {
if (x == 0) return 1;
else return 1 ll * x * fact ( x - 1) ;
}
int main () {
printf ("% lld \n " , fact (15) );
}
An implementation of the above algorithm in Python.
def fact (x):
if x == 0: return 1
return x * fact (x - 1)
print ( fact (6) )
3
2.4 Calculate Fibonacci numbers
The Fibonacci sequence (fn ) is defined as following:
(
1 if n = 0, 1
fn =
fn−1 + fn−2 if n ≥ 2.
Important note: Every sequenced that is defined by recursive identity like this is susceptible to recursion.
The pseudocode for Fibonacci algorithm:
Algorithm 5 Calculate Fibonacci numbers
1: procedure Fibo x
( )
2: if x≤1 then
3: return 1
4: else
5: return Fibo (x − 1) + Fibo (x − 2) . Recurse
6: end if
7: end procedure
An implementation of the above algorithm in C.
# include < stdio .h >
int fibo ( int n) {
if (n <= 1) return 1;
return fibo (n - 1) + fibo (n - 2) ;
}
int main () {
printf ("% lld \n " , fibo (5) ) ;
}
An implementation of the above algorithm in Python.
def fibo (x):
if x <= 1: return 1
return fibo (x - 1) + fibo (x - 2)
print ( fibo (6) )
2.5 Calculate binomial coefficients
n
Binomial coefficients
k are the number of ways to select a set of k elements from n different elements without
taking into account the order of arrangement of these elements (i.e., the number of unordered sets).
To calculate binomial coefficient, the first method is to use the analytic formula
n n!
=
k k!(n − k)!
This formula can be easily deduced from the problem of ordered arrangement (number of ways to select k different
elements from n different elements). The second way is to use the recurrence formula, discovered by Pascal:
n n−1 n−1
= +
k k−1 k
It is easy to deduce this using the analytic formula.
n
Note that for n < k, the value of
k is assumed to be 0.
Using the recurrence formula, we have the following algorithm:
4
Algorithm 6 Calculate binomial coefficients
1: procedure Binom n, k ( )
2: if n<k then
3: return0
4: else if k=0 or k=n then
5: return 1
6: else
7: return Binom (n − 1, k − 1) + Binom (n − 1, k) . Recurse
8: end if
9: end procedure
An implementation of the above algorithm in C.
# include < stdio .h >
int binom ( int n , int k) {
if (n < k) return 0;
if (k == 0 || k == n) return 1;
return binom (n - 1, k - 1) + binom ( n - 1, k);
}
int main () {
printf ("% lld \n " , binom (5 , 3) ) ;
}
An implementation of the above algorithm in Python.
def binom (n , k):
if n < k : return 0
if k == 0 or k == n: return 1
return binom (n - 1, k - 1) + binom ( n - 1, k)
print ( binom (5 , 3) )
2.6 Length of Collatz sequences
The infamous Collatz's conjecture stated as following: Given a positive integer x, we keep do the following operation
(
x
2 if x is even
x=
3x + 1 if x is odd
then after a finite number of operations, we will arrive at 1. Now, if we assume that the conjecture is actually
correct, we want to compute the number of operations that will reduce x to 1.
Now, letc(n) denote the number of such operations. Then if n is even, we have c(n) = c(n/2) + 1 and if n is
odd, we have c(n) = c((3n + 1)/2) + 2. This gives us the following algorithm:
Algorithm 7 Length of Collatz sequence
1: procedure Collatz n ( )
2: if n=1 then
3: return 0
4: else if n is even then
5: return Collatz (n/2) + 1 . Recurse
6: else
7: return Collatz ((3n + 1)/2) + 2 . Recurse
8: end if
9: end procedure
An implementation of the above algorithm in C.
# include < stdio .h >
int collatz ( int n) {
if (n == 1) return 0;
5
else if ( n & 1) return collatz ((3 * n + 1) / 2) + 2;
return collatz (n / 2) + 1;
}
int main () {
printf ("% lld \n " , collatz (13) ) ;
}
An implementation of the above algorithm in Python.
def collatz ( n):
if n == 1: return 0
elif n & 1: return collatz ((3 * n + 1) // 2) + 2
return collatz (n // 2) + 1
print ( collatz (13) )
2.7 Tower of Hanoi
This infamous problem was first published by Eduouard Lucas is 1883. The puzzle can be described as following:
The puzzle consists of three rods and a number of disks of different sizes, which can slide onto any rod.
The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at
the top, thus making a conical shape.
The objective of the puzzle is to move the entire stack to another rod, obeying the following simple
rules:
1. Only one disk can be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another
stack or on an empty rod.
3. No larger disk may be placed on top of a smaller disk
H¼nh 1: The Tower of Hanoi puzzle
The crux to solving this puzzle is to solve it recursively. So instead of trying to solve the entire puzzle at once,
we will solve it recursively. First, we try to moving just the largest disk. We can't move it at the beginning, because
all the other disks are in the way. So first we have to move those n − 1 disks to a spare peg. And then after we move
the largest disk, we have to move those n − 1 disks back on top of it. So now, the problem reduces to solving two
instances of the same problem with n − 1. The base case is when n = 0, we have to do nothing at all.
Using this recursive scheme, we have the following recurrence relation for the number of steps we need to solve
this puzzle. Let cn be the number of steps we need to solve this puzzle for n disks, then cn = 2cn−1 + 1. It's easy
to see from this recurrence relation that the general formula is 2n − 1, and we can prove this easily with induction.
Pseudocode for algorithm to solve the puzzle
Algorithm 8 Tower of Hanoi
1: procedure Hanoi n, src, dst, tmp
( )
2: if n>0 then
3: Hanoi(n − 1, src, tmp, dst) . Recurse
4: move diskn from src to dst
5: Hanoi(n − 1, tmp, dst, src) . Recurse
6: end if
7: end procedure
6
An implementation by Python can be found below.
A = [3 , 2 , 1]
B = []
C = []
def hanoi (n , src , dst , tmp ) :
if n > 0:
hanoi (n - 1 , src , tmp , dst )
dst . append ( src . pop () )
print (A , B , C , ' ######### ', sep = '\ n ')
hanoi (n - 1 , tmp , dst , src )
hanoi (3 , A , B , C)
