1. Recursion: The Mirrors
Chapter 2
Recursion:
The Mirrors

2. Recursive Solutions
Recursion is an extremely powerful problem-solving technique
Breaks a problem in smaller identical problems
An alternative to iteration, which involves loops
A sequential search is iterative
Starts at the beginning of the collection
Looks at every item in the collection in order
A binary search is recursive
Repeatedly halves the collection and determines which half could contain the item
Uses a divide and conquer strategy
© 2005 Pearson Addison-Wesley. All rights reserved

3. Recursive Solutions Facts about a recursive solution
A recursive method calls itself
Each recursive call solves an identical, but smaller problem
A test for the base case enables the recursive calls to stop
Base case: a known case in a recursive definition
Eventually, one of the smaller problems must be the base case
© 2005 Pearson Addison-Wesley. All rights reserved

4. Recursive Solutions
Four questions for construction of recursive solutions
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?
© 2005 Pearson Addison-Wesley. All rights reserved

5. Writing a String Backward
Problem
Given a string of characters, write it in reverse order
Recursive solution
Each recursive step of the solution diminishes by 1 the length of the string to be written backward
Base case: write the empty string backward
© 2005 Pearson Addison-Wesley. All rights reserved

6. Writing a String Backward
void writeBackward( char *str ){ if (str[0] == '\0') return; writeBackward( str + 1 ); cout << str[0]; }
© 2005 Pearson Addison-Wesley. All rights reserved

7. The Fibonacci Sequence
Recurrence relation
F(n) = F(n-1) + F(n-2)
Base cases
F(1) = 1, F(2) = 1
© 2005 Pearson Addison-Wesley. All rights reserved

8. Implementation: Recursive
int fib(int n){
// Precondition: n is a positive integer
// Postcondition: Returns the nth Fib. number
if ( n <= 2 )
return 1;
else
return fib(n-1) + fib(n-2); }
© 2005 Pearson Addison-Wesley. All rights reserved

9. Implementation: Iterative
int iterativeFib(int n){
// Initialize base cases:
int previous = 1; // initially fib(1)
int current = 1; // initially fib(2)
int next = 1; // result when n is 1 or 2
// compute next Fibonacci values when n >= 3
for (int i = 3; i <= n; ++i){
// current is fib(i-1)
// previous is fib(i-2)
next = current + previous; // fib(i)
previous = current; // get ready for the
current = next; // next iteration }
return next;
© 2005 Pearson Addison-Wesley. All rights reserved

10. Binary Search A high-level binary search if (anArray is of size 1) {
Determine if anArray’s item is equal to value }
else {
Find the midpoint of anArray
Determine which half of anArray contains value
if (value is in the first half of anArray) {
binarySearch (first half of anArray, value)
binarySearch(second half of anArray, value)
© 2005 Pearson Addison-Wesley. All rights reserved

11. Binary Search Implementation issues:
How will you pass “half of anArray” to the recursive calls to binarySearch?
How do you determine which half of the array contains value?
What should the base case(s) be?
How will binarySearch indicate the result of the search?
© 2005 Pearson Addison-Wesley. All rights reserved

12. Binary Search
int binarySearch(int *arr, int low, int high, int key){ if (low > high) return -1; int mid = (low + high) / 2; if (arr[mid] == key) return mid; if (arr[mid] > key) return binarySearch(arr,low,mid - 1,key); return binarySearch(arr,mid + 1,high,key); }
© 2005 Pearson Addison-Wesley. All rights reserved

13. Recursion and Efficiency
Some recursive solutions are so inefficient that they should not be used
Factors that contribute to the inefficiency of some recursive solutions
Overhead associated with method calls
Inherent inefficiency of some recursive algorithms
Do not use a recursive solution if it is inefficient and there is a clear, efficient iterative solution
© 2005 Pearson Addison-Wesley. All rights reserved

14. Finding Connected Components
Suppose that we want to segment cell nuclei in a tissue image. Suppose that it is a gray level image (its pixels contain intensity values between 0 and 255).
For this purpose, we first apply some image processing to obtain its black-and-white form. In this form, each pixel value is either 0 and 1. Then, we are going to find the connected components on the black pixels.
So, we write a recursive function for finding the connected components.
© 2005 Pearson Addison-Wesley. All rights reserved

15. Finding Connected Components
Suppose that we want to segment cell nuclei in a tissue image. Suppose that it is a gray level image (its pixels contain intensity values between 0 and 255).
For this purpose, we first apply some image processing to obtain its black-and-white form. In this form, each pixel value is either 0 and 1. Then, we are going to find the connected components on the black pixels.
So, we write a recursive function for finding the connected components.
© 2005 Pearson Addison-Wesley. All rights reserved

16. Finding Connected Components
Similarly, in the image below, we want to identify individual buildings. Connected components analysis can be used after obtaining a black-and-white image of buildings.
© 2005 Pearson Addison-Wesley. All rights reserved

17. Finding Connected Components
Similarly, in the image below, we want to identify individual buildings. Connected components analysis can be used after obtaining a black-and-white image of buildings.
© 2005 Pearson Addison-Wesley. All rights reserved

18. Finding Connected Components
int **findConnectedComponents(int **A, int row, int column){
int **labels, i, j, currLabel;
labels = new int *[row];
for ( i = 0; i < row; i++ ){
labels[i] = new int[column];
for ( j = 0; j < column; j++ )
labels[i][j] = 0; }
currLabel = 1;
for ( i = 0; i < row; i++ )
if ( A[i][j] && !labels[i][j] ) fourConnectivity( A, labels, row, column,
i, j, currLabel++);
return labels;
© 2005 Pearson Addison-Wesley. All rights reserved

19. Finding Connected Components
void fourConnectivity( int **A, int **labels,
int row, int column,
int i, int j, int currLabel){
if (A[i][j] == 0) return;
if (labels[i][j] > 0) return;
labels[i][j] = currLabel;
if (i-1 >= 0)
fourConnectivity(A,labels,row,column,i-1,j,currLabel);
if (i+1 < row)
fourConnectivity(A,labels,row,column,i+1,j,currLabel);
if (j-1 >= 0)
fourConnectivity(A,labels,row,column,i,j-1,currLabel);
if (j+1 < column)
fourConnectivity(A,labels,row,column,i,j+1,currLabel); }
© 2005 Pearson Addison-Wesley. All rights reserved