Welcome to the IndexedListTester program. Enter 'h' for a list of commands. >c cat in the hat ate a rat New list created... cat in the hat ate a rat >e 3 hat >e 0 cat >L 7 >x hat 3 >x rat 6 >x computer -1 >i 6 tasty cat in the hat ate a tasty rat >i 0 The The cat in the hat ate a tasty rat >a quickly The cat in the hat ate a tasty rat quickly >r 1 pig The pig in the hat ate a tasty rat quickly >d 7 Deleted item is tasty The pig in the hat ate a rat quickly >t quickly rat a ate hat the in pig The >t The pig in the hat ate a rat quickly >p 2 5 in the hat >q Goodbye. |
Provided to you is an incomplete Java source code file, IndexedListViaLink1. As usual, your job is to fill in the missing method bodies, which are marked by the comment "STUB!!".
An instance of this class represents an indexed list (or indexed sequence, if you prefer). A list (or sequence) is a collection of elements which come one after the other, in a linear fashion. (Stacks and queues are particular examples.) The term indexed is meant to indicate that here we are talking about lists each of whose elements can be referred to by its index, or position, within the list (as in first, second, third, etc.). Following the computer science convention, we will start counting at zero, so that the indexes of the elements in such a list are 0, 1, 2, etc.
Readers familiar with the java.util.List interface —or the java.util.ArrayList class that implements it— will recognize that what you are being asked to implement here is a very simplified version thereof, supporting only the most fundamental operations, including elemAt(), indexOf(), insert(), delete(), and replace(). (Our choice of method names differs somewhat from those in the List interface, mind you. But the effects are the same.)
As the name IndexedListViaLink1 suggests, instances of that class make use of instances of the class Link1 to serve as the underlying building blocks.
Note that, in Link1, both its item and next instance variables are declared to be public, meaning that you can refer to them directly in other classes. Thus, for example, in a Java class that has a variable junk of type Link1, you would use the syntax junk.item and junk.next to refer to the instance variables of the Link1 object to which junk refers/points.
Also provided is a "tester" program, IndexedListTester.java, that you should find very useful. It lets the user create a list of Strings, following which the user can display its elements, insert and delete elements, etc., in an interactive fashion. It repeatedly prompts the user to enter a command, reads it, and then carries out that command. To display a list of (examples of) commands that are supported, enter h (for "help") at the prompt. To the right is an example dialog between a user and this program.
With only the code that has been given to you, you should be able to use the tester program to create a list of Strings and to display it.
You will notice that the lone instance variable in the IndexedListViaLink1 class is dummy, which is of type Link1. Its purpose is to store a reference/pointer to a "dummy" node whose next field refers/points to the node containing the list element at position zero. In the case of a list being empty, its dummy node's next field has value null.
Using a dummy node is a very well known technique that simplifies, to some degree, the code needed in the insert() and delete() methods. Specifically, it makes it so that neither inserting nor removing an item at position zero need be treated as a special case. (Concretely, what that means is that no if-else structure is needed in those methods.)
To illustrate (using ASCII art!), here is what the underlying representation of a list containing dog, cat, and cow would "look like":
dummy +---+ | * | +-+-+ | | V +---+---+ +---+---+ +---+---+ +---+----+ | | *-+----->|dog| *-+----->|cat| *-+----->|cow|null| +---+---+ +---+---+ +---+---+ +---+----+ item next item next item next item next |
Note: To clarify, the instance variable is called dummy; the value of that variable is a reference/pointer to the Link1 object that serves as the "dummy node".
In order to keep the diagram simple, the item field in each node is shown as having value equal to some animal. In reality, each node's item field is a reference to an animal object, just as each node's next field is a reference to another node (which is a Link1 object).
There are six stubbed methods to be completed:
To delete an element, you first need to establish a reference/pointer to the node immediately preceding the one holding the element to be deleted.
If you have time at the end, rewrite the body of the first constructor so that, after creating the dummy node, it uses the insert() method to place the elements into the list (rather than making use of the pntr local variable). Think about the order in which the elements should be inserted. Is it first-to-last or last-to-first? Does it make any difference, in terms of running time? If so, why?
As usual, submit your completed work (the IndexedListViaLink1.java file) into the appropriate dropbox. Make sure to include, within the comments of the Java class, the names of all your team members.