PCS4
Week 3:
recursion (book: section 7.15)
Recursion
2
Remember from Math-lessons:
mathematical induction?
We have a functional proposition,
say P(n), where n ϵ {7, 8, 9, 10, 11, 12, 13, . . .}.
Suppose we can prove that: "starting point"
• P(7) is true, and
"wheel"
• ( A k : k>7 : P(k-1) P(k) )
Then we have proved: ( A n : n>=7 : P(n) )
Really? Can you prove me that, for instance, P(12) holds?
Answer: yes, I can ! ! !:
Start at the starting point and turn the wheel 5 times.
You see: P(12) is true.
3
And now: programming recursively
We need to implement a method. One of the parameters is an integer
which is greater than or equal to a "starting point".
Consider the functional proposition P:
P(n) : calling the method for value n for that integer parameter
(with n>= "starting point") does exactly what it is supposed to do.
If we implement the method correct, we have:
( A n : n>=starting point : P(n) )
One way of proving it, is by induction (recursion): prove
• P(starting point) is true, and
• ( A k : k>starting point : P(k-1) P(k) )
4
An example
The factorial of a non-negative integer n,
written as n! (pronounced "n factorial"),
is defined as the number of ways to arrange n different objects in a row.
Example: you have 5 objects.
Place them one by one in a row.
• For the first item you can choose out of 5 objects,
• for the second out of 4 objects,
• for the third out of 3 objects,
• etc.
The number of arrangements is 5*4*3*2*1,
so the answer is 120 possible arrangements.
5
The example about n factorial, continued
A recursive definition for n!:
• n! := 1 for n=0
• n! := n * (n-1)! for n>0
Assignment: implement a method to calculate
n factorial.
Solution:
public int fac(int n)
// for n>=0 the method returns n!
{
??????
}
6
The example about n factorial, continued
public int fac(int n)
// for n>=0 the method returns n!
{
return 1;
}
This implementation is correct for n=0.
public int fac(int n)
// for n>=0 the method returns n!
{
return n * fac(n-1);
}
If fac(n-1) does it correct, then this implementation
is correct for n.
7
The example about n factorial, continued
The former ideas combined:
public int fac(int n)
// for n>=0 the method returns n!
{
if (n == 0)
{
return 1;
}
else
{
return n * fac(n-1);
}
}
This implementation is correct for all n with n>=0.
8
Example: you want to calculate the sum of the first n integers
in an array.
public int getSum(int[] numbers, int n)
{
int sum = 0;
for ( int k = 0; k < n; k++)
{ sum = sum + numbers[k]; }
return sum;
}
or recursively:
public int getSum(int[] numbers, int n)
{
if ( n == 0 ) base case
{ return 0; }
else recursive call
{ return getSum(numbers, n-1) + numbers[n-1]; }
}
9
Example: array X: { 7, 3, 5, 9, 3, 6}
public int getSum(int[] numbers, int n)
{
if ( n == 0 ) { return 0; }
else { return getSum(numbers, n-1) + numbers[n-1]; }
}
a= a gets the value 10
getSum(X,2) ;
return getSum(X,1) + returns 7 + X[1], so returns
10
X[1];
returns 0 + X[0], so returns
return getSum(X,0) + 7
X[0];
return 0; returns 0
10
About a recursive method
• A recursive method is a method that calls itself.
• "Turning the wheel" should not continue forever:
in that chain of recursive calls you must reach a
"starting point" where the recursive calls stop.
• if "Turning the wheel" goes on forever, you get
troubles. At a certain moment all available
memory is occupied and you will get a "stack-
overflow-error".
11
Extra: towers of Hanoi
12
Hanoi, a difficult problem (if you don't like recursion)
3 piles (towers), numbered 1, 2, 3.
At startup: all discs are on pile 1 from "big to small".
At finish: all discs should be on pile 3.
A move: move a disc from one pile to another pile,
but you are not allowed to put a bigger disc on a smaller disc.
In how many moves can you solve the problem? And how should you
do it?
A solution without recursion: terrible to program.
A solution by using recursion: pretty simple.
13
Hanoi, a difficult problem (if you don't like recursion)
// Give me instructions about how to move
// nrOfDiscs discs from the pile numbered
// startPile to the pile numbered endPile.
// You may use the pile numbered helpingPile.
// Precondition: nrOfDiscs > 0.
public void Hanoi( int startPile,
int endPile,
int helpingPile,
int nrOfDiscs )
{
. . . // todo
}
Solution: next week.
14
