| << Chapter < Page | Chapter >> Page > |
The basic notions of creating a recursive algorithm on a composite design pattern structure are
This is the Interpreter Design pattern. Notice that no checks of the type of data being processed (e.g. base case or inductive case) are necessary. Each data object knows intrinsically what it is and thus what it should do. This is called "polymorphic dispatching" when an abstract method is called on an abstract data object, resulting in a particular concrete behavior corresponding to the concrete object used. In other words, we call a method on a list, but get the behavior of an empty list if that what the list is, or we get the behavior of a non-empty list if that is what the list is.
In order to prove that a recursive algorithm will eventually complete, one must show that every time the recursive call is made, the "problem" is getting "smaller". The "problem" is usually the set of possible objects that the recursive call could be called upon. For instance, when recursively processing a list, every call to the rest of the list is calling on a list that is getting progessively shorter. At times, one cannot prove that the problem is definitely getting smaller. This does not mean that the algorithm will never end, it just means that there is a non-zero probability that it will go on forever.
One of the key aspects of a recursive algorithm is that in the inductive case, the inductive method makes the recursive call to another object's method. But in doing so, it has to wait for the called method to return with the needed result. This method that is waiting for the recursive call to return is called a " pending operation ". For instance, at the time the empty list (base case) is reached during a recursive algorithm on a list, every non-empty node in that list has a pending operation.
Below is an example of generally what is happening in four linked objects during the call to the recursive method of the first object:
Consider the problem of finding the last element in a list. Again we need to interpret what it means to be the last element of (a) the empty list and (b) a non-empty list.
null .
null is a special value in Java that can be assigned to any variable of
Object type to signify that the variable is not referencing any
Object at all.To recapitulate, here is how a list can find its own last element.
How does rest use the first element of the enclosing list to help find the last element of the enclosing list?
Here is the code.
/**
* Represents the abstract list structure.*/
public interface IList {/**
* Returns the last element in this IList.*/
Object getLast();/*** Given the first of the preceding list, returns the last element of the preceding list.
* @param acc the first of the preceding list.*/
Object getLastHelp(Object acc);} |
/**
* Represents empty lists.*/
public class MTList implements IList {// Singleton Pattern
public static final MTList Singleton= new MTList();
private MTList() {}/**
* Returns null to signify there is* no last element in the empty list.
*/public Object getLast() {
return null;}
/*** Returns acc, because being the
* first element of the preceding* list, it is the last element.
*/public Object getLastHelp(
Object acc) {return acc;
}} |
/**
* Represents non-empty lists.*/
public class NEList implements IList {private Object _first;
private IList _rest;public NEList(Object f, IList r) {
_first = f;_rest = r;
}/**
* Passes first to rest and asks for* help to find the last element.
*/public Object getLast() {
return _rest.getLastHelp(_first);}
/*** Passes first to rest and asks for
* help to find the last element.*/
public Object
getLastHelp (Object acc) {
return _rest.
getLastHelp (_first);
}} |
The above algorithm to compute the last element of a list is another example of forward accumulation. Note that in the above,
getLast is not recursive while
getLastHelp is recursive. Also note that for the
NEList , the last computation in
getLastHelp is a recursive call to
getLastHelp on
_rest . There is no other computation after the recursive call returns. This kind of recursion is called
tail recursion . Tail recursion is important for program performance. A smart compiler can recognize tail recursion and generate code that speeds up the computation by bypassing unnecessary setup code each time a recursive call is made.
.
Notification Switch
Would you like to follow the 'Principles of object-oriented programming' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|