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

6.2 Node Lists
Using an index is not the only means of referring to the place where an element
appears in a sequence. If we have a sequence S implemented with a (singly or doubly)
linked list, then it could possibly be more natural and efficient to use a node instead
of an index as a means of identifying where to access and update S. In this section, we
define the node list ADT, which abstracts the concrete linked list data structure
(Sections 3.2 and 3.3) using a related position ADT that abstracts the notion of
"place" in a node list.
6.2.1 Node-Based Operations
Let S be a (singly or doubly) linked list. We would like to define methods for S that
take nodes as parameters and provide nodes as return types. Such methods could
provide significant speedups over index-based methods, because finding the index
of an element in a linked list requires searching through the list incrementally from
its beginning or end, counting elements as we go.
For instance, we could define a hypothetical method remove(v) that removes the
element of S stored at node v of the list. Using a node as a parameter allows us to
remove an element in O(1) time by simply going directly to the place where that
node is stored and then "linking out" this node through an update of the next and
prev links of its neighbors. Similarly, we could insert, in O(1) time, a new element e
into S with an operation such as addAfter(v, e), which specifies the node v
after which the node of the new element should be inserted. In this case, we simply
"link in" the new node.
Defining methods of a list ADT by adding such node-based operations raises the
issue of how much information we should be exposing about the implementation of
our list. Certainly, it is desirable for us to be able to use either a singly or doubly
326