Data Structures and Algorithms in Java[1].pdf - Fulvio Frisone

linked list without revealing this detail to a user. Likewise, we do not wish to allow
a user to modify the internal structure of a list without our knowledge. Such
modification would be possible, however, if we provided a reference to a node in
our list in a form that allowed the user to access internal data in that node (such as a
next or prev field).
To abstract and unify the different ways of storing elements in the various
implementations of a list, we introduce the concept of position, which formalizes
the intuitive notion of "place" of an element relative to others in the list.
6.2.2 Positions
So as to safely expand the set of operations for lists, we abstract a notion of
"position" that allows us to enjoy the efficiency of doubly or singly linked list
implementations without violating object-oriented design principles. In this
framework, we view a list as a collection of elements that stores each element at a
position and that keeps these positions arranged in a linear order. A position is itself
an abstract data type that supports the following simple method:
element(): Return the element stored at this position.
A position is always defined relatively, that is, in terms of its neighbors. In a list, a
position p will always be "after" some position q and "before" some position s
(unless p is the first or last position). A position p, which is associated with some
element e in a list S, does not change, even if the index of e changes in S, unless we
explicitly remove e (and, hence, destroy position p). Moreover, the position p does
not change even if we replace or swap the element e stored at p with another
element. These facts about positions allow us to define a set of position-based list
methods that take position objects as parameters and also provide position objects
as return values.
6.2.3 The Node List Abstract Data Type
Using the concept of position to encapsulate the idea of "node" in a list, we can
define another type of sequence ADT called the node list ADT. This ADT supports
the following methods for a list S:
first():
Return the position of the first element of S; an error occurs if S is empty.
last():
Return the position of the last element of S; an error occurs if S is empty.
prev(p):
327