1. Handout-16 Recursion
Overview
Introduction to recursion and recursive methods
Simple popular recursive algorithms
Writing recursive methods

2. Recursion
We saw earlier that a method could call another method and this could lead to a series of frames created on the stack.
In fact there is nothing preventing a method to call itself, or call another method which lead to calling the first method. Such a method is called a recursive method.
A well-defined recursive method has
A base case;
A recursive step which must always get “closer” to the base case from one invocation to another.
The code of a recursive method must be structured to handle both the base case and the recursive case.
Each call to the method sets up a new execution environment, with new parameters and local variables.
As always, when the method completes, control returns to the method that invoked it (which may be an earlier invocation of itself).

3. Recursion: The Factorial Function
The factocial function is defined as:
n! = n*(n-1)*(n-2)*…*1
import java.io.*;
class Factorial {
public static int factorial(int num) {
if (num == 0)
return 1;
else
return num*factorial(num-1); }
public static void main (String[] args) throws IOException {
BufferedReader stdin= new BufferedReader( new InputStreamReader(System.in));
int n, answer;
System.out.println("Enter an integer:");
n=Integer.parseInt(stdin.readLine());
answer = factorial(n);
System.out.println("The factorial of " + n + " is " + answer);

4. Recursion: Sample Execution Trace
Factorial: A Sample Trace
factorial (6) =
=(6*Factorial(5))
=(6*(5*Factorial(4)))
=(6*(5*(4*Factorial(3))))
=(6*(5*(4*(3*Factorial(2)))))
=(6*(5*(4*(3*(2*Factorial(1))))))
=(6*(5*(4*(3*(2*1)))))
=(6*(5*(4*(3*2))))
=(6*(5*(4*6)))
=(6*(5*24))
=(6*120)
=720

5. Recursion: sumOfSquares
sumOfSquares: Specified as:
sumSquares(m,n)=m^2+(m+1)^2+(m+2)^3+…+n^2
import java.io.*;
class SumOfSquares {
static int sumSquares(int from,int to) {
if (from < to)
return from*from +
sumSquares(from+1,to);
else
return from*from; }

6. Recursion: sumOfSquares (cont.)
sumOfSquares (continued)
public static void main (String[] args) throws IOException {
BufferedReader stdin= new BufferedReader( new InputStreamReader(System.in););
int from, to, answer;
System.out.println("Enter the smaller");
String input=stdin.readLine();
from = Integer.parseInt(input); System.out.println("Enter the bigger");
input=stdin.readLine();
to = Integer.parseInt(input);
answer = sumSquares(from,to);
System.out.println("Sum of Squares from "+ from + " to " +to+" is "+ answer); }

7. Recursion: sumOfSquares Execution Trace
sumSquares: A Sample Trace
sumSquares (5,10) =
=(25+sumSquares(6,10))
=(25+(36+sumSquares(7,10))) =(25+(36+(49+sumSquares(8,10))))
=(25+(36+(49+(64+sumSquares(9,10)))))
=(25+(36+(49+(64+(81+(sumSquares(10,10)))))))
=(25+(36+(49+(64+(81+100)))))
=(25+(36+(49+(64+181))))
=(25+(36+(49+245)))
=(25+(36+294))
=(25+330)
=355

8. Recursion: The Fibonacci Function
The famous Fibonacci function is defined as
fib 0 = 1
fib 1 = 1
fib n = fib(n-1)+fib(n-2), n>=2.
import java.io.*;
class Fibonacci {
static int fibonacci (int num) {
if (num == 0 || num == 1)
return 1;
else
return (fibonacci(num-1) + fibonacci(num-2)); }

9. Recursion: The Fiboacci Function
Fibonacci
public static void main (String[] args) throws IOException {
BufferedReader stdin= new BufferedReader( new InputStreamReader(System.in));
int n, answer;
System.out.println("Enter an integer:");
String input=stdin.readLine();
n = Integer.parseInt(input);
answer = fibonacci(n);
System.out.println("The "+n+ "th Fibonacci number is: "+ answer); }

10. Simple Recursive Algorithms (cont.)
Exercises: Write complete recursive programs for the following algorithms
1 power(x,y) that implements x^y using repeated additions and without using multiplication. Assume x to be a floating point value and y to be a nonnegative integer.
2 gcd(m,n) that implements the Euclid’s algorithm of finding the greatest common divisor of m and n. Assume m and n to be positive integers.
3. isPalindrome() which given a string prints an informative error message saying whether or not the given string is a palindrome (reads the same when read from left to right or from right to left).