Why is the statement else if (width == 1) { return 1; } in the getArea
method unnecessary?
Answer:
Suppose we omit the statement. When computing the area of a triangle with width
1, we compute the area of the triangle with width 0 as 0, and then add 1, to
arrive at the correct area.
Self Check 13.2
How would you modify the program to recursively compute the area of a square?
Answer:
You would compute the smaller area recursively, then return smallerArea + width + width - 1.
[][][][] [][][][] [][][][] [][][][]
Of course, it would be simpler to compute the area simply as width * width. The results are identical because
Self Check 13.3
In some cultures, numbers containing the digit 8 are lucky numbers. What is
wrong with the following
method that tries to test whether a number is lucky?
public static boolean isLucky(int number)
{
int lastDigit = number % 10;
if (lastDigit == 8) { return true; }
else
{
return isLucky(number / 10); // Test the number without the last digit
}
}
Answer:
There is no provision for stopping the
recursion. When a number < 10 isn’t 8, then
the method should return false and stop.
Self Check 13.5
Consider the following recursive method:
public static int mystery(int n)
{
if (n <= 0) { return 0; }
else
{
int smaller = n - 1;
return mystery(smaller) + n * n;
}
}
To debug recursive methods with a debugger, you need to be particularly careful,
and watch the call stack to understand which nested call you currently are in.
Thinking Recursively
Thinking recursively is easy if
you can recognize a subtask that
is similar to the original task.
Problem: test whether a sentence is a palindrome
Palindrome: a string that is equal to itself when you reverse all characters
A man, a plan, a canal – Panama!
Go hang a salami, I'm a lasagna hog
Madam, I'm Adam
Implement isPalindrome Method: How To 13.1
public class Sentence
{
private String text;
/**
Constructs a sentence.
@param aText a string containing all characters of the sentence
*/
public Sentence(String aText)
{
text = aText;
}
/**
Tests whether this sentence is a palindrome.
@return true if this sentence is a palindrome, false otherwise
*/
public boolean isPalindrome()
{
. . .
}
}
Thinking Recursively: How To 13.1
1. Consider various ways to simplify inputs.
Here are several possibilities:
Remove the first character.
Remove the last character.
Remove both the first and last characters.
Remove a character from the middle.
Cut the string into two halves.
Thinking Recursively: How To 13.1
2. Combine solutions with simpler inputs into a solution of the original problem.
Most promising simplification: Remove first and last characters adam, I'm Ada, is a palindrome too!
Thus, a word is a palindrome if
The first and last letters match, and
Word obtained by removing the first and last letters is a palindrome
What if first or last character is not a letter? Ignore it.
If the first and last characters are letters, check whether they match;
if so, remove both and test shorter string
If last character isn't a letter, remove it and test shorter string
If first character isn't a letter, remove it and test shorter string
Thinking Recursively: How To 13.1
3. Find solutions to the simplest inputs.
Strings with two characters
No special case required; step two still applies
Strings with a single character
They are palindromes
The empty string
It is a palindrome
Thinking Recursively: How To 13.1
4. Implement the solution by combining the simple cases and the reduction step:
public boolean isPalindrome()
{
int length = text.length();
// Separate case for shortest strings.
if (length <= 1) { return true; }
// Get first and last characters, converted to lowercase.
char first = Character.toLowerCase(text.charAt(0));
char last = Character.toLowerCase(text.charAt(length - 1));
if (Character.isLetter(first) && Character.isLetter(last))
{
// Both are letters.
if (first == last)
{
// Remove both first and last character.
Sentence shorter = new Sentence(text.substring(1, length - 1));
return shorter.isPalindrome();
}
else
{
return false;
}
}
else if (!Character.isLetter(last))
{
// Remove last character.
Sentence shorter = new Sentence(text.substring(0, length - 1));
return shorter.isPalindrome();
}
else
{
// Remove first character.
Sentence shorter = new Sentence(text.substring(1));
return shorter.isPalindrome();
}
}
Recursive Helper Methods
Sometimes, a task can be solved by handing it off to a recursive helper method.
Sometimes it is easier to find a recursive solution if you make a slight change to the original problem.
Consider the palindrome test of previous slide.
It is a bit inefficient to construct new Sentence objects in every step
Rather than testing whether the sentence is a palindrome, check whether a
substring is a palindrome:
/**
Tests whether a substring of the sentence is a palindrome.
@param start the index of the first character of the substring
@param end the index of the last character of the substring
@return true if the substring is a palindrome
*/
public boolean isPalindrome(int start, int end)
Recursive Helper Methods: isPalindrome
public boolean isPalindrome(int start, int end)
{
// Separate case for substrings of length 0 and 1.
if (start >= end) { return true; }
// Get first and last characters, converted to lowercase.
char first = Character.toLowerCase(text.charAt(start));
char last = Character.toLowerCase(text.charAt(end));
if (Character.isLetter(first) && Character.isLetter(last))
{
if (first == last)
{
// Test substring that doesn’t contain the matching letters.
return isPalindrome(start + 1, end - 1);
}
else
{
return false;
}
}
else if (!Character.isLetter(last))
{
// Test substring that doesn’t contain the last character.
return isPalindrome(start, end - 1);
}
else
{
// Test substring that doesn’t contain the first character.
return isPalindrome(start + 1, end);
}
}
Recursive Helper Methods
Provide a method to call the helper method with positions that test the entire string:
public boolean isPalindrome()
{
return isPalindrome(0, text.length() - 1);
}
This call is not recursive
The isPalindrome(String) method
calls the helper method isPalindrome(String, int, int).
An example of overloading
The public will call isPalindrome(String) method.
isPalindrome(String, int, int) is the recursive helper method.
Self Check 13.6
Do we have to give the same name to both isPalindrome methods?
Answer:
No — the second one could be given a different name such as substringIsPalindrome.
The Efficiency of Recursion: Fibonacci Sequence
Fibonacci sequence is a sequence of numbers defined by: f1 = 1 f2 = 1 fn = fn-1 + fn-2
Enter n: 6
Entering fib: n = 6
Entering fib: n = 5
Entering fib: n = 4
Entering fib: n = 3
Entering fib: n = 2
Exiting fib: n = 2 return value = 1
Entering fib: n = 1
Exiting fib: n = 1 return value = 1
Exiting fib: n = 3 return value = 2
Entering fib: n = 2
Exiting fib: n = 2 return value = 1
Exiting fib: n = 4 return value = 3
Entering fib: n = 3
Entering fib: n = 2
Exiting fib: n = 2 return value = 1
Entering fib: n = 1
Exiting fib: n = 1 return value = 1
Exiting fib: n = 3 return value = 2
Exiting fib: n = 5 return value = 5
Entering fib: n = 4
Entering fib: n = 3
Entering fib: n = 2
Exiting fib: n = 2 return value = 1
Entering fib: n = 1
Exiting fib: n = 1 return value = 1
Exiting fib: n = 3 return value = 2
Entering fib: n = 2
Exiting fib: n = 2 return value = 1
Exiting fib: n = 4 return value = 3
Exiting fib: n = 6 return value = 8
fib(6) = 8
Call Tree for Computing fib(6)
Figure 2 Call Pattern of the Recursive fib Method
The Efficiency of Recursion
Method takes so long because it computes the same values over and over.
The computation of fib(6) calls fib(3) three times.
Imitate the pencil-and-paper process to avoid computing the values more than
once.
In most cases, the iterative and recursive approaches have comparable efficiency.
Occasionally, a recursive solution runs much slower than its iterative
counterpart.
In most cases, the recursive solution is only slightly slower.
The iterative isPalindrome performs only slightly better than recursive
solution.
Each recursive method call takes a certain amount of processor time
Smart compilers can avoid recursive method calls if they follow simple patterns.
Most compilers don't do that.
In many cases, a recursive solution is easier to understand and implement
correctly than an iterative solution.
Iterative isPalindrome Method
public boolean isPalindrome()
{
int start = 0;
int end = text.length() - 1;
while (start < end)
{
char first = Character.toLowerCase(text.charAt(start));
char last = Character.toLowerCase(text.charAt(end);
if (Character.isLetter(first) && Character.isLetter(last))
{
// Both are letters.
if (first == last)
{
start++;
end--;
}
else
{
return false;
}
}
if (!Character.isLetter(last)) { end--; }
if (!Character.isLetter(first)) { start++; }
}
return true;
}
Self Check 13.10
Is it faster to compute the triangle numbers recursively, as shown in Section 13.1, or is it faster to use a loop that computes 1 + 2 + 3 + . . . + width?
Answer:
The loop is slightly faster. Of course, it is even faster to simply compute width * (width + 1) / 2.
Permutations
Using recursion,
you can find all
arrangements of
a set of objects.
Design a class that will list all permutations of a string.
A permutation is a rearrangement of the letters.
The string "eat" has six permutations:
"eat"
"eta"
"aet"
"ate"
"tea"
"tae"
Permutations
Problem: Generate all the permutations of "eat".
First generate all permutations that start
with the letter 'e', then 'a' then 't'.
How do we generate the permutations that start with 'e'?
We need to know
the permutations of the substring "at".
But that’s the same problem—to generate all
permutations—
with a simpler input
Prepend the letter 'e' to all the permutations you found of 'at'.
Do the same for 'a' and 't'.
Provide a special case for the simplest strings.
The simplest string is the empty string, which has a single permutation—itself.
Problem: to compute the value of arithmetic expressions such as:
3 + 4 * 5
(3 + 4) * 5
1 - (2 - (3 - (4 - 5)))
Computing expression is complicated
* and / bind more strongly than + and -
Parentheses can be used to group subexpressions
Syntax Diagrams for Evaluating an Expression
Figure 3
Mutual Recursions
An expression can broken down into a sequence of terms, separated by + or -
.
Each term is broken down into a sequence of factors, separated by * or /
.
Each factor is either a parenthesized expression or a number.
The syntax trees represent which operations should be carried out first.
Syntax Tree for Two Expressions
Mutually Recursive Methods
In a mutual recursion, a set of cooperating methods calls each other repeatedly.
To compute the value of an expression, implement 3 methods that call each other
recursively:
getExpressionValue
getTermValue
getFactorValue
The getExpressionValue Method
public int getExpressionValue()
{
int value = getTermValue();
boolean done = false;
while (!done)
{
String next = tokenizer.peekToken();
if ("+".equals(next) || "-".equals(next))
{
tokenizer.nextToken(); // Discard "+" or "-"
int value2 = getTermValue();
if ("+".equals(next)) value = value + value2;
else value = value - value2;
}
else
{
done = true;
}
}
return value;
}
The getTermValue Method
The getTermValue method calls getFactorValue in the same way, multiplying or dividing the factor values.
The getFactorValue Method
public int getFactorValue()
{
int value;
String next = tokenizer.peekToken();
if ("(".equals(next))
{
tokenizer.nextToken(); // Discard "("
value = getExpressionValue();
tokenizer.nextToken(); // Discard ")"
}
else
{
value = Integer.parseInt(tokenizer.nextToken());
}
return value;
}
Using Mutual Recursions
To see the mutual recursion clearly, trace
through the expression (3+4)*5:
getExpressionValue calls getTermValue
getTermValue calls getFactorValue
getFactorValue consumes the ( input
getFactorValue calls getExpressionValue
getExpressionValue returns eventually with the value of 7,
having consumed 3 + 4. This is the recursive call.
getFactorValue consumes the ) input
getFactorValue returns 7
getTermValue consumes the inputs * and 5 and returns 35
getExpressionValue returns 35
Recursion terminates when all the tokens of the input
string are consumed.
Backtracking is a problem solving technique that builds up partial solutions that get
increasingly closer to the goal.
If a partial solution cannot be completed, one abandons it
And returns to examining the other candidates.
Characteristic properties needed to use backtracking for a problem.
A procedure to examine a partial solution and determine whether to
Accept it as an actual solution.
Abandon it (either because it violates some rules or because it is clear that it
can never lead to a valid solution).
Continue extending it.
A procedure to extend a partial solution, generating one or more solutions that
come closer to the goal.
In a backtracking algorithm, one
explores all paths towards a solution.
When one path is a dead end, one needs
to backtrack and try another choice.
Backtracking
Backtracking can then be expressed with the following recursive algorithm.
Solve(partialSolution)
Examine(partialSolution).
If accepted
Add partialSolution to the list of solutions.
Else if continuing
For each p in extend(partialSolution)
Solve(p).
Backtracking - Eight Queens Problem
The Problem: position eight queens on a chess board so that none of them attacks another according to the rules of chess.
There are no two queens on the same row, column, or diagonal
A Solution to the Eight Queens Problem:
Backtracking - Eight Queens Problem
To examine a partial solution:
If two queens attack
each other, reject it.
Otherwise, if it has eight queens, accept it.
Otherwise, continue.
To extend a partial solution:
Add another queen on an empty square
For efficiency, place first queen in row 1, the next in row 2, and so on
Backtracking
Provide a class PartialSolution
that collects the queens in a partial solution,
and that has methods to examine and extend the solution
public class PartialSolution
{
private Queen[] queens;
public int examine() { . . . }
public PartialSolution[] extend() { . . . }
}
Backtracking
The examine method simply checks whether two queens attack each other:
public int examine()
{
for (int i = 0; i < queens.length; i++)
{
for (int j = i + 1; j < queens.length; j++)
{
if (queens[i].attacks(queens[j])) { return ABANDON; }
}
}
if (queens.length == NQUEENS) { return ACCEPT; }
else { return CONTINUE; }
}
Backtracking
The extend method takes a given solution
And makes eight copies of it.
Each copy gets a new queen in a different column.
public PartialSolution[] extend()
{
// Generate a new solution for each column
PartialSolution[] result = new PartialSolution[NQUEENS];
for (int i = 0; i < result.length; i++)
{
int size = queens.length;
// The new solution has one more row than this one
result[i] = new PartialSolution(size + 1);
// Copy this solution into the new one
for (int j = 0; j < size; j++)
{
result[i].queens[j] = queens[j];
}
// Append the new queen into the ith column
result[i].queens[size] = new Queen(size, i);
}
return result;
}
Backtracking
To determine if two queens attack each other diagonally
