COSC 2006 Data Structures I
Recursion I
Topics

Recursion vs. Iteration

Characteristics of Recursion

Recursive Examples

Constructing & Tracing Recursive
Solutions
Introduction
Recursion makes complex problems easier
by breaking them down into simpler
versions of the same problem
 Recursion is easy to understand (trust me!)
 The only thing mysterious about recursion
is why so many students find it frightening!

Introduction
Recursion

Math definition:


a solution to a problem that is defined in terms of a
simpler version of itself
Programming definition:

a function which calls itself
Gist



Take a problem and break it down into
identical, but smaller, problems
Do it in such a manner that eventually the
smaller problems become trivial to solve.
These are the base cases.
Once you have analyzed your problem in
this way, you can write a method that


Checks for and solves the base case (easy!)
Otherwise calls itself on smaller problems
(easy!)
7/14/2017
Recursive Examples


Some concepts are naturally defined recursively
Examples:

Multiplication:


ab
= a (b - 1 ) + a
=a+a+...+a
base case = a
b-times
Exponentiation:

ab
= a( b-1) a
=aaa...a
base case = a
b-times
Recursive Examples
Some everyday situations can be
described recursively
 Examples:



Searching in dictionaries
Exercise:

What other real-life situations do you believe
are recursive?
Example: Searching Dictionary
 Steps
when searching in a dictionary
 Option1:
 Lengthy
Sequential search
& inefficient if the dictionary had
many pages
Example: Dictionary
Option 2:




Open to a page (somewhere in the middle):
this divides the problem into smaller problems
Is it on the page you opened to? Retrieve the
definition (base case #1)
Is this the only page in the dictionary? Return
failure: it is not in the dictionary (base case
#2)
If not, determine which half it is in and recurse
on that half as if it were the whole dictionary
Four Questions
How can you define the problem in terms
of a smaller problem of the same type?
 How does each recursive call diminish the
size of the problem?
 What instance of the problem can serve
as the base case?
 As the problem size diminishes, will you
reach this base case?

7/14/2017
Example: Searching Dictionary

Algorithm: First Draft
// Search a dictionary for a word by using
// recursive binary search
if (Dictionary contains 1 page)
scan the page for the word
else
{
Open a page near the middle
Determine which half contains the word
if (word in first half)
search first half for the word
else
search second half for the word
}
Example: Searching Dictionary

Observations on first draft:



Search Dictionary
The problem of searching for a
word is reduced by half each time
Once we divide the dictionary into
Search First Half
two halves, we use the same
strategy to search the appropriate of Dictionary
half
Special case (base / degenerate /
termination):


Different from all other cases (single
page)
Does not contain recursive call
O
R
Search Second Half
of Dictionary
Example: Searching Dictionary

Algorithm: Second Draft
search (in aDictionary: Dictionary,in Word: string)
// Search a dictionary for a word by using
// recursive search
{
if (aDictionary contains 1 page) // Base case
scan the page for the word
else
{ Open aDictionary to point to a page near the middle
Determine which half contains the word
if (word in first half of aDictionary)
search (first half of aDictionary, word)
else
search (second half of aDictionary, word)
} // end if
} // end search
Example: Searching Dictionary

Observations


The recursive one is more efficient than the iterative
solution
The Fact function fits the model of recursive solution




It calls itself
At each recursive call the value of page diminishes by half
The base case occurs when it is one page
If there are pages in dictionary, the base case is always
reached
Recursive Functions Criteria
1. Function calls itself
2. Each call solves an simpler (smaller in size),
but identical problem
3. Base case is handled differently from all other
cases and enables recursive calls to stop
4. The size of the problem diminishes and
ensures reaching the base case
Example: Factorial

Iterative definition:
factorial(n) = n * (n-1) * (n-2) * … * 1
n>0
factorial(0) = 1

for any integer
A recurrence relation
factorial(n) = n * [(n-1) * (n-2) * … * 1]
factorial(n) = n * factorial(n-1)

A recursive definition of factorial
1, if n  0

factorial(n)  
n * factorial(n  1), if n  0
7/14/2017
Example: Factorial (cont)
1, if n  0

factorial(n)  
n * factorial(n  1), if n  0
public static int fact(int n) {
if (n == 0) {
return 1;
else {
return n * fact(n-1);
}
}
7/14/2017
Recursion vs. Iteration

Iteration





Involves loops
Needs a termination condition
Based on initial, final, & step values
Solutions could be lengthy & complex
Recursion




Involves recursive calls
Provide some elegant & short solutions for complex
problems
Needs a termination condition
Based on divide & conquer
Example: Factorial (cont)
public static int fact(int n) {
int temp;
System.out.println("Entering factorial: n = " + n);
if (n == 0) {
temp= 1;
}
else {
temp = n * fact(n-1);
}
System.out.println("Leaving factorial: n = "+ n );
return temp;
}
Call:
System.out.println("Factorial(4):" + factorial(4));
7/14/2017
Example: Factorial

Observations


The iterative solution is more efficient than the
recursive one
The Fact function fits the model of recursive solution





It calls itself
At each recursive call the value of n diminishes by 1
The base case occurs when n = 0
If n is non-negative, the base case is always reached
Any problem with the recursion version?
Stack Frames
System Stack
used to control which function is currently active
and to reverse the order of function calls when
returning.
Stack Frame
a variable size piece of memory that is pushed
onto the system stack each time a function call is
made.
Stack Frames
Stack Frame contains:
space for all local (automatic) variables
the return address - the place in the program to which
execution will return when this function ends
the return value from the function
all parameters for a function (with actual parameter values
copied in
The stack frame on top of the stack always
represents the function being executed at any point
in time - only the stack frame on top of the stack
is accessible at any time.
Stack Frames
public class Test {
public static void main (String [] args) {
double a =1, b=2, c= 3 x= 4;
System.out.println(“Line function”+ Line (a,b,x));
System.out.println (“Quadratic function”+Quadratic (a,b,c,x));
}
static double Line (double a, double b, double x) {
double y = a*x+b;
return y;
}
static double Quadratic (double a, double b, double c, double x) {
double y = a*x*x+b*x+c;
return y;
}
Types of Recursion

Direct recursion:



Indirect recursion:


When a function calls itself
Multiple recursion
When a function calls another function, that
eventually calls the original function
Mutual recursion:

When two functions call each other
Multiple Recursion
Fibonacci Sequence: 0 1 1 2 3 5 8 13 21
44
each number in sequence is the sum of the
previous two numbers (except the first two)
Fibonacci number 0 = 0
Fibonacci number 1 = 1
all other Fibonacci numbers are defined as
the sum of the previous two
Fibonacci Numbers (skip the
rabbits)
{
1
if n is 1 or 2
Fib(n) =
Fib(n-1) + Fib(n-2) otherwise
Public static int fib(int n) {
if (n <= 2) {
return 1
Multiple
calls
and
base
else {
return fib (n-1) + fib(n-2)
}
}
See textbook for trace … how many times
is fib(3) computed?
cases
Review

In a recursive solution, the ______
terminates the recursive processing.
local environment
 pivot item
 base case
 recurrence relation

27
Review

A ______ is a mathematical formula that
generates the terms in a sequence from
previous terms.
local environment
 pivot item
 base case
 recurrence relation

28
Review

The factorial of n is equal to ______.
n–1
 n – factorial (n–1)
 factorial (n–1)
 n * factorial (n–1)

29
Review

The base case for a recursive definition
of the factorial of n is ______.
factorial (–1)
 factorial (0)
 factorial (1)


30
factorial (n – 1)
Review

What would happen if a negative value is
passed to a method that returns the
factorial of the value passed to it?




31
the method will calculate the correct value for the
factorial of the number
the method will calculate a negative value for the
factorial of the number
the method would terminate immediately
an infinite sequence of recursive calls will occur
Review

In the box trace, each box roughly
corresponds to a(n) ______.
recursive relation
 activation record
 base case
 pivot item

32
Review

In the box trace, each box contains all of
the following EXCEPT ______.
the values of the references and primitive
types of the method’s arguments
 the method’s local variables
 the method’s class variables
 a placeholder for the value returned by each
recursive call from the current box

33
Review

In the box trace for a recursive method, a
new box is created each time ______.
the method is called
 the method returns a value
 the object is created


34
the object is initialized