View
247
Download
0
Category
Preview:
Citation preview
1
Chapter 15
Recursive Algorithms
2
Objectives
• Learn to write recursive algorithms for– mathematical functions and – nonnumerical operations.
• Decide when to use recursion and when not to.
• Describe some example recursive programs– quicksort algorithm– 8-queen problem.
3
Recursive methods
• A method is recursive if it invokes itself either directly or indirectly.
• direct recursion: class A {
int m(int k) { … m(k-1) … }.
}
• Indirect directionm1(… ) { … m2(…) … }
m2(… ) { …. m3(…) … }
m3(…) { …. m1(…) … }
4
Recursion
• The factorial of N is the product of the first N positive integers:
N * (N – 1) * (N – 2 ) * . . . * 2 * 1
• The factorial of N can be defined recursively as
1 if N = 1
factorial( N ) =
N * factorial( N-1 )
otherwise
• Recursive function is vary direct and easy to implement in any programming language like java or C that supports recursion.
5
Recursive Method
• Implementing the factorial of N recursively will result in the following method.
public int factorial( int N ) {
if ( N == 1 ) {
return 1;}else {
return N * factorial( N-1 );}
}
6
Directory Listing• List the names of all files in a given directory and its
subdirectories.
public void directoryListing(File dir) {
//assumption: dir represents a directoryString[] fileList = dir.list(); //get the contentsString dirPath = dir.getAbsolutePath();
for (String fileName : fileList) { File file = new File(dirPath + "/" +fileName );
if (file.isFile()) { //it's a file out.println( file.getName() );
} else { // it’s a directory directoryListing( file ); //it's a directory
} //so make a} //recursive call
}
7
Anagram
• List all anagrams (permutations) of a given word.
WordWord C A T
C T A
A T C
A C T
T C A
T A C
AnagramsAnagrams
8
Anagram Solution
• The basic idea is to make recursive calls on a sub-word after every rotation. Here’s how:
CC AA TT RecursionRecursion
AA TT CC
TT CC AA
RecursionRecursion
RecursionRecursion
Rotate Left
Rotate Left
C A T
C T A
A T C
A C T
T C A
T A C
9
Anagram Method
End caseEnd case
TestTest
Recursive caseRecursive case
public void anagram( String prefix, String suffix ) {String newPrefix, newSuffix;int numOfChars = suffix.length();
if (numOfChars == 1) {//End case: print out one anagramSystem.out.println( prefix + suffix );
} else {for (int i = 1; i <= numOfChars; i++ ) {
newSuffix = suffix.substring(1, numOfChars);newPrefix = prefix + suffix.charAt(0);anagram( newPrefix, newSuffix );//recursive call//rotate left to create a rearranged suffixsuffix = newSuffix + suffix.charAt(0);
}}
}
10
Towers of Hanoi
• The goal of the Towers of Hanoi puzzle is to move N disks from peg 1 to peg 3:
– You must move one disk at a time.
– You must never place a larger disk on top of a smaller disk.
11
Towers of Hanoi Solution
12
towers Of Hanoi Methodpublic void Hanoi(int N, //number of disks
int from, //origin peg int to, //destination peg int spare ){ //"middle" peg
if ( N == 1 ) {moveOne( from, to );
} else { Hanoi( N-1, from, spare, to ); moveOne( from, to ); Hanoi( N-1, spare, to, from );
}}private void moveOne( int from, int to ) {
out.println( from + " ---> " + to );}
13
Quicksort
• To sort an array from index low to high, we first select a pivot element p. – Any element may be used for the pivot, but for this
example we will user number[low].
• Move all elements less than the pivot to the first half of an array and all elements larger than the pivot to the second half. Put the pivot in the middle.
• Recursively apply quicksort on the two halves.
14
Quicksort Partition
15
The partition method
int partition(int[] n, int start, end end) { int pivot = n[start] ; do { while( start < end && n[end] >= pivot ) end -- ; if(start < end ) { // found a number < pivot n[start] = n[end]; // copy end to start ; while( start < end && n[start] <= pivot) start++; if(start < end) { // found a number > pivot n[end] = n[start]; // copy start to end } while(start < end) ;n[start] = pivot;return start;}
16
Example
• 23 17 5 90 12 44 38 84 77• 23 17 5 90 12 44 38 84 77 23 is the pivot• 23 17 5 90 12 44 38 84 77• 12 17 5 90 12 44 38 84 77• 12 17 5 90 90 44 38 84 77• 12 17 5 90 90 44 38 84 77• 12 17 5 23 90 44 38 84 77• return 3 the final pivot position.
17
quicksort Method
public void quickSort( int[] number, int low, int high ) {
if ( low < high ) {int mid = partition( number, low,
high );quickSort( number, low, mid-1 );quickSort( number, mid+1, high );
}}int[] input = new int[] {45, 97, 30, 21, 11, 50,14, 30, 10 };void sort() { quicksort( input, 0, iput.length – 1); }
18
Example
• 45,50,30,21,11,97,14,30,10
• partition 10,30,30,21,11,14,45,97,50 return 6
• sort(_,0,5)10,11,14,21,30,30,45,97,50
• sort(_,7,8)10,11,14,21,30,30,45,50,97.
19
When Not to Use Recursion
• When recursive algorithms are designed carelessly, it can lead to very inefficient and unacceptable solutions.
• For example, consider the following:
public int fibonacci( int N ) {
if (N == 0 || N == 1) {return 1;
} else {return fibonacci(N-1) + fibonacci(N-2);
}}
20
Excessive Repetition
• Recursive Fibonacci ends up repeating the same computation numerous times.
21
Nonrecursive Fibonacci
public int fibonacci( int N ) {
int fibN, fibN1, fibN2, cnt;
if (N == 0 || N == 1 ) {return 1;
} else {
fibN1 = fibN2 = 1;cnt = 2;while ( cnt <= N ) {
fibN = fibN1 + fibN2; //get the next fib no.fibN1 = fibN2;fibN2 = fibN;cnt ++;
}return fibN;
}}
22
When Not to Use Recursion
• In general, use recursion if– A recursive solution is natural and easy to understand.– A recursive solution does not result in excessive duplicate
computation.– The equivalent iterative solution is too complex.
• For some problems, recursion seems inevitable!!
23
The N-Queen Problem• Place N queens on a NxN board so that none of
them is able to attack any other using the standard chess queen's moves.
• The rule:– Two queens cannot appear at the same row/column or diagonal line.
• A solution to the 8-queen problem:
24
Solution
• public class NQueen {• pubic final number N;• int[] solution;• public NQueen(int n ) {• N = n; • solution = new int[n] ;• }• boolean findFirst() {• }
26
The solution
Recommended