Scribd
Upload
37 views

Week 3: Recursion (Book: Section 7.15)

The document discusses recursion through examples of calculating factorials and summing array elements recursively. It explains that a recursive method calls itself, and each recursive call must eventually reach a "starting point" or base case to avoid infinite looping. The example of the Towers of Hanoi puzzle is given as a problem well-suited to a recursive solution due to its repetitive moving of discs between piles. Implementation of a recursive Hanoi method to print move instructions is listed for a future task.

Uploaded by

Rusnac Cristi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
37 views

Week 3: Recursion (Book: Section 7.15)

The document discusses recursion through examples of calculating factorials and summing array elements recursively. It explains that a recursive method calls itself, and each recursive call must eventually reach a "starting point" or base case to avoid infinite looping. The example of the Towers of Hanoi puzzle is given as a problem well-suited to a recursive solution due to its repetitive moving of discs between piles. Implementation of a recursive Hanoi method to print move instructions is listed for a future task.

Uploaded by

Rusnac Cristi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 14

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

You might also like