Recursion

Overview

For this homework you will implement several static methods that will perform simple tasks on generic lists. We will provide you with four public tests (one for each of the routine problems)

Objectives

This project is designed to help you practice implementing recursive algorithms. The solutions to these problems should be quite short.

Grading

The homework is worth 100 points.

Clarifications

Any clarifications or corrections associated with this project will be available at Clarifications.

Code Distribution

The project's code distribution is available by checking out the project named RecursionExercises. The code distribution provides you with the following:

A package named genericLists - Has a shell for the class you will implement.
A package named tests - Includes the public tests (PublicTests.java ). Notice that you are not required to write student tests for this project; however, we recommend you do so.

Specifications

Parameterizing Static Methods

When you look in the code distribution you'll see method prototypes that look like this:

public static <T> void duplicateFirst(List<T> list)

Between the keyword "static" and the return type "void" you see <T>. This is how static methods can be parameterized for use with generic types. "T" represents a type that will be determined later when the method is invoked.

Creating Sublists of Lists

To successfully implement your methods, you will find it quite helpful to be able to generate a sublist from a List. Java makes this very easy! The List interface includes a method with the following prototype:

List<E>subList(int fromIndex, int toIndex)

Important: Note that the parameter "toIndex" is not inclusive! For example, suppose x is the list: <a, b, c, d, e>. Then x.subList(2, 4) would give you the sublist: <c, d>,not the sublist <c, d, e> as you might have expected.(This may remind you of the subString method of the String class.)

Methods for you to Implement

You will implement the following methods:

public static <T> void duplicateFirst(List<T> list)
This method will replace all of the elements in the list with copies of the first element of the list. For example, if the original list is <a, b, c, d, e>, then after the method is over the list will look like: <a, a, a, a, a>.
public static <T> void duplicateLast(List<T> list)
This method will replace all of the elements in the list with copies of the last element of the list. For example, if the original list is <a, b, c, d, e>, then after the method is over the list will look like: <e, e, e, e, e>.
public static <T> boolean anyDuplicates(List<T> list)
This method will return false if all of the elements of the list are distinct, and true if there are any duplicates.
public static <T extends Comparable<T>> T findLargest(List<T> list)
This method will return the largest element of the list. (Note that the elements in the list must be Comparable to one another).

Requirements

You may not use any loops anywhere in your code.
You may not add any static variables.
You may not add any instance variables.
You may not use any helper-methods. (You may not write any methods other than those that are already provided.)
You must attempt to submit your project immediately after checking out the project (even if you have not implemented any methods). This will allow you to verify that the submission process is working as expected.
You should submit your project often. This will keep versions of your project in the submit server that are easy to retrieve (you can also get previous versions from your CVS repository). If your computer crashes or you experience any other problem you will have a permanent backup in the submit server.
No student tests are required for this project.
Style
- Good variable names.
- Style as defined by the Eclipse Format Element option (Source → Format → Format Element) or as specified in Code Conventions for the JavaTM Programming Language (focus on the following sections: Indentation, Declarations, Statements, White Space, and Naming Conventions).
- Although you should avoid source lines exceeding 80 characters, you will not be penalize if they are present in your code.