2.1.1. Defining the ADT¶

What basic operations do we want our lists to support? Our common intuition about lists tells us that a list should be able to grow and shrink in size as we insert and remove elements. We should be able to insert and remove elements from anywhere in the list. We should be able to gain access to any element’s value, either to read it or to change it. We must be able to create and clear (or reinitialize) lists. It is also convenient to access the next or previous element from the “current” one.

Now we can define the ADT for a list object in terms of a set of operations on that object. We will use an interface to formally define the list ADT. List defines the member functions that any list implementation inheriting from it must support, along with their parameters and return types.

True to the notion of an ADT, an interface does not specify how operations are implemented. Two complete implementations are presented later in later modules, both of which use the same list ADT to define their operations. But they are considerably different in approaches and in their space/time tradeoffs.

The code below presents our list ADT in Python. Any implementation for a container class such as a list should be able to support different data types for the elements. Languages that support generics (Java) or templates (C++) give more control over the element types.

The comments given with each member function describe what it is intended to do. However, an explanation of the basic design should help make this clearer. Given that we wish to support the concept of a sequence, with access to any position in the list, the need for many of the member functions such as insert and moveToPos is clear. The key design decision embodied in this ADT is support for the concept of a current position. For example, member moveToStart sets the current position to be the first element on the list, while methods next and prev move the current position to the next and previous elements, respectively. The intention is that any implementation for this ADT support the concept of a current position. The current position is where any action such as insertion or deletion will take place. An alternative design is to factor out position as a separate position object, sometimes referred to as an iterator.

# List class ADT.
class List:
  # Remove all contents from the list, so it is once again empty.
  def clear(self):

  # Insert "it" at the current location.
  def insert(self, it):

  # Append "it" at the end of the list.
  def append(self, it):

  # Remove and return the current element.
  def remove(self):

  # Set the current position to the start of the list.
  def moveToStart(self):

  # Set the current position to the end of the list.
  def moveToEnd(self):

  # Move the current position one step left, no change if already at beginning.
  def prev(self):

  # Move the current position one step right, no change if already at end.
  def next(self):

  # Return the number of elements in the list.
  def length(self):

  # Return the position of the current element.
  def currPos(self):

  # Set the current position to "pos".
  def moveToPos(self, pos):

  # Return true if current position is at end of the list.
  def isAtEnd(self):

  # Return the current element.
  def getValue(self):
  
  # Tell if the list is empty or not.
  def isEmpty():

Settings

Saving...
Server Error
Resubmit

The List member functions allow you to build a list with elements in any desired order, and to access any desired position in the list. You might notice that the clear method is a “convenience” method, since it could be implemented by means of the other member functions in the same asymptotic time.

A list can be iterated through as follows:

L.moveToStart()
while not L.isAtEnd():
  it = L.getValue()
  doSomething(it)
  L.next()

In this example, each element of the list in turn is stored in it, and passed to the doSomething function. The loop terminates when the current position reaches the end of the list.

The list class declaration presented here is just one of many possible interpretations for lists. Our list interface provides most of the operations that one naturally expects to perform on lists and serves to illustrate the issues relevant to implementing the list data structure. As an example of using the list ADT, here is a function to return true if there is an occurrence of a given integer in the list, and false otherwise. The find method needs no knowledge about the specific list implementation, just the list ADT.

def find(L, k):
    """Return true if k is in list L, false otherwise."""
    for n in L:
        if k == n:
            return true  # Found k
    return false         # k not found

In languages that support it, this implementation for find could be rewritten as a generic or template with respect to the element type. While making it more flexible, even generic types still are limited in their ability to handle different data types stored on the list. In particular, for the find function generic types would only work when the description for the object being searched for (k in the function) is of the same type as the objects themselves. They also have to be comparable when using the == operator. A more realistic situation is that we are searching for a record that contains a key field whose value matches k. Similar functions to find and return a composite type based on a key value can be created using the list implementation, but to do so requires some agreement between the list ADT and the find function on the concept of a key, and on how keys may be compared.

There are two standard approaches to implementing lists, the array-based list, and the linked list.