Recursion

A method is recursive if it makes a call to itself.

For example:
public void printDown (int n){
System.out.println( n);
printDown(n-1);
}
Is a recursive method. In fact, it ‘recurses’
infinately….
A method which recurses infinately is not of much use.
There are many problems which can be solved
recursively and, in fact, be coded more simply by the
use of recursion.
Let’s first learn to PROPERLY use recursion
on familiar applications…
Designing a recursive solution
The idea behind using recursion to solve a problem is
to simplify the solution by
defining the problem in terms of itself.
For example:
Suppose we want to write a method power(x,n), which
raises x to the nth power. And suppose we don’t
know how to compute Xn , but we know that Xn = X *
Xn-1 .
We have start of a recursive solution!!
Xn = X * Xn-1
We might try writing the power method:
public int power (int x, int n) {
return x * power(x, n-1);
}
This is logical, because IF we had a power method,
the return statement is correct …. And we ARE
writing a power method.
There is only one problem ……………
Let’s try our method by tracing a call to power(3,3)
power(3,3) returns 3 * power (3,2)
need to call power(3,2)
to find result
power(3,2) returns 3 * power (3,1)
need to call power(3,1)
to find result
power(3,1) returns 3 * power (3,0)
need to call power(3,0)
to find result
power(3,0) returns 3 * power (3,-1)
need to call power(3,1)
to find result
We could do this all day …. Infinite recursion again!!
A method which uses recursion should ALWAYS have at
least one path which does not recurse in order to
avoid infinite recursion.
Where do we come up with that???
We must find ONE case of the problem in which we
know the solution. For example, we KNOW X1 = X.
public int power (int x, int n) {
if ( n == 1)
return x;
else
return x * power(x, n-1);
}
Let’s try our method by tracing a call to power(3,3)
power(3,3) returns 3 * power (3,2)
need to call power(3,2)
to find result
power(3,2) returns 3 * power (3,1)
need to call power(3,1)
to find result
power(3,1) returns 3
So, that means
power(3,2) return 3 * 3 (or 9)
power(3,3) returns 3 * 9 (or 27)
Another recursive solution
Suppose we want to write a method factorial(n) which
computes n! (mathematical symbol defined as n* n1* n-2 * .. * 1, and 0! = 1.
To avoid infinite recursion we need to think of
something we know.
We know: 0! = 1
Now, define the unknown part of the solution in terms
of the solution itself. N! = N * (N-1)!
public int factorial ( int n) {
if ( n == 0)
return 1;
else
return n * factorial( n-1);
}
Trace it for factorial(4) and check if it works!!
The solution should be 24.
Another recursive solution
Suppose we want to write a method which
printDown(n) which prints the values from n downto 1
… without using a loop.
We know: If n is 1, we just want to print 1
Define the unknown part of the solution in terms of the
method itself.
print n
call printDown(n-1) to print the rest of the values
public void printDown( int n) {
if ( n == 1)
System.out.println(1);
else{
System.out.println(n);
printDown(n-1);
}
Try a call to printDown(5).
What is the maximum number of calls to printDown that
were active at once?? I counted 5.
Another recursive solution
Suppose we want to write a method named printRev(s)
which prints the characters in the String s in reverse
… without using a loop.
We know: If s has a length of 1, we just print s
Define the unknown part of the solution in terms of the
method itself.
call printRev(rest of the string) to print the rest of
the string in reverse
print the first character
public void printRev( String s) {
if ( s.length() == 1)
System.out.print(s);
else{
printRev(s.substring(1));
System.out.print(s.charAt(0));
}
}
Try a call to printRev(“java”).
What is the maximum number of calls to printRev that
were active at once?? I counted 4.
Clearly, these solutions we have been looking at can be
much more simply written using a loop. Additionally,
the effect of a method call on execution time makes
these solutions highly inefficient ….
These problems were not best solved using recursion.
But, there ARE problems that are much more
simply solved, often at no cost to efficiency,
using recursion.
Palindromes
Design a method that will determine if a String is a
palindrome (reads the same forward and backward).
For example, Madame I’m Adam is a palindrome.
Our method signature will look like this:
public boolean palindrome(String s)
We will not worry about punctuation for now … assume
that the String has been scanned and all punctuation
removed, and letters are all lower case.
Palindromes continued
What do we know??
if the string has one character it is a palindrome
if the string is empty it is implicitly a palindrome
What if we Had a method palindrome ….
if the first and last character are the same
then
if the substring in between those chars is a
palindrome
the string is a palindrome
else
it string is not a palindrome
Palindromes continued
public boolean palindrome(String s){
if (s.length() <= 1)
return true;
else{
char first = s.charAt(0);
char last = s.charAt(s.length() -1);
if (first == last)
return palindrome(s.substring(1, s.length() -1);
else
return false;
}
}