Intro to Abstract Data Types and Sequences

1. it works
2. it is easy to understand and modify
3. it is reasonably efficient

• code is easier to understand (e.g., it is easier to see "high-level" steps being performed, not obscured by low-level code);
• implementations of ADTs can be changed (e.g., for efficiency) without requiring changes to the program that uses the ADTs;
• ADTs can be reused in future programs.

There are two parts to each ADT:

1. the public or external part, which consists of:
   • the conceptual picture (the user's view of what the object looks like, how the structure is organized)
   • the conceptual operations (what the user can do to the ADT)
2. the private or internal part, which consists of:
   • the representation (how the structure is actually stored)
   • the implementation of the operations (actual algorithms used)

Note: There are many possible operations that could be defined for each ADT. They often fall into these categories:

1. initialize
2. add data
3. access data
4. remove data

Our first ADT is the sequence: an ordered collection of items, one of which is the "current" item. Recall that the external view includes the "conceptual picture" and the set of "conceptual operations". The conceptual picture us something like this:

      item 1     item 2     item 3     . . .     item n
                   ^
                   |
                current

banana, apple, lemon, mango
  ^
  |
 current

banana, apple, lemon, mango
          ^
          |
         current

banana, apple, lemon, mango
                        ^
                        |
                      current

banana, apple, lemon, mango
                                ^
                                |
                             current

Here's an outline of the Java definition for the Sequence class, implemented using an array to store the items in the sequence (the bodies of the methods are not filled in for now):

public class Sequence {
  //*** methods ***

  // constructor
    public Sequence() { ... }      

  // add items
    public void addBefore(Object ob) { ... }  
    public void addAfter(Object ob) { ... }   

  // remove items
    public void removeCurrent() { ... } throws NoCurrentException { ... }

  // iteration
    public void start() { ... }    
    public Object getCurrent() throws NoCurrentException { ... }  
    public void advance() throws NoCurrentException { ... }       
    public boolean isCurrent() { ... }        

  // other methods
    public int size() { ... }      
    public boolean lookup(Object ob) { ... }  

  // *** fields ***
    private Object[] items; // the items in the sequence
    private int current;    // the index of the current item
    private int numItems;   // the number of items in the sequence
}  

Notes:

      BEFORE:  item 1    item 2    item 3    ...    item n
                           ^
                           |
                          current


      AFTER:   item 1    item 2    NEW ITEM    item 3    ...    item n
                                      ^
                                      |
                                     current

      BEFORE:  item 1    item 2    item 3    ...    item n


      AFTER:   item 1    item 2    item 3    ...    item n    NEW ITEM
                                                                 ^
                                                                 |
                                                                current

Now let's think about the actual code. We'll need two cases, depending on whether there is a current item. If there is, we'll need to move all of the items after the current item one place to the right in the array before inserting the new item. In both cases, the new item becomes the current item, and in both cases, we need to worry about whether the array is full. So here's an outline for the code:

public void addAfter( Object ob ) {
// if the array is full, expand it

// if there is a current item:
//    o move all items after the current item one place to the right
//    o increment current (so that it is the index of the space
//      in which the new item will be stored)

// if there is no current item:
//    o set current to be the index of the first free space at the
//      end of the array

// in both cases, store the new item in the space indexed by current
// and increment the count of the number of items in the sequence
}

Note that the addBefore method will also need code to expand the array and to move items to the right; therefore, it seems like a good idea to define (private) methods for those tasks. Here's the final code for addAfter, including calls to the new private methods:

    public void addAfter(Object ob) {
	// if the array is full, expand it
 	if (numItems == items.length) expandArray();

	if (isCurrent()) {
	  // move all items after the current item one place to the right
	  // and increment current
	    moveItemsRight(current+1);
	    current++;
	}
	else {
	  // set current to be the index of the first free space at the
	  // end of the array
	    current = numItems;
	}

	// store the new item in the space indexed by current
	// and increment the count of the number of items in the sequence
	items[current] = ob;
	numItems++;
    }

In general, when you write code it is a good idea to think about special cases. For example, does addAfter work when the sequence is empty? When the current item is the first one? When it is the last one? You should think through these cases (perhaps drawing pictures to illustrate what the sequence looks like before the call to addAfter, and how the call to addAfter affects the sequence). Decide if the code works as is, or if some modifications are needed.

public void removeCurrent() throws NoCurrentException {
// error if there is no current item

// otherwise, move all of the items after the current item one place to
// the left and decrement the count of the number of items in the sequence


}

Note that moving the items after the current item to the left accomplishes two things:

1. It overwrites the value of the current item, thus removing it from the sequence.
2. It leaves the current field set to the correct value whether or not the removed item was the last one in the sequence!

Here's the final code for removeCurrent, using a new (private) method to move items to the left:

    public void removeCurrent() throws NoCurrentException {
	// error if there is no current item
	if (!isCurrent()) throw new NoCurrentException();
	else {
	  // otherwise, move all of the items after the current item one
	  // place to the left and decrement the count of the number of
	  // items in the sequence
	    moveItemsLeft(current+1);
	    numItems--;
	}
    }

As for the current field, the constructor should initialize it so that there is no current item. In general, the current field will contain the index of the current item. What should it contain if there is no current item? Any value will do as long as we can tell the difference between a sequence with and without a current item (methods isCurrent, advance, getCurrent, and removeCurrent all need to make that distinction). A valid index is any value in the range 0 to numItems-1, so if current has a value outside that range, it means that there is no current item. So a reasonable value to use in the constructor is -1.

Below is the code for the constructor (including the declaration of the static field for the initial size). This code uses 10 as the initial size. In practice, the appropriate initial size will probably depend on the context in which the Sequence class is used. The advantage of a larger initial size is that more "add" operations can be performed before it is necessary to expand the array (which requires copying all items). The disadvantage is that if the initial array is never filled, then memory is wasted. The requirements for memory usage and runtime performance of the application that uses the Sequence class, as well as the expected sizes of the sequences that it uses should be used to determine the appropriate initial size.

private static final int INITSIZE = 10;

public Sequence() {
    numItems = 0;
    items = new Object[INITSIZE];
    current = -1;
}