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

An interface for a queue ADT, but using different method names. Methods
include peek() (same as front()), offer(e) (same as
enqueue(e)), and poll() (same as dequeue()).
Set:
An interface extending Collection to sets.
The Java Collections Framework also includes several concrete classes
implementing various combinations of the above interfaces. Rather than list each of
these classes here, however, we discuss them at more appropriate places in this
book. One topic we would like to stress now, however, is that any class
implementing the java.util.Collection interface also implements the
java.lang.Iterable interface; hence, it includes an iterator() method
and can be used in a for-each loop. In addition, any class implementing the
java.util.List interface also includes a listIterator() method, as well.
As we observed above, such interfaces are useful for looping through the elements
of a collection or list.
6.4.2 The java. util.LinkedList Class
The java.util.Linked List class contains a lot of methods, including all of
the methods of the deque ADT (Section 5.3) and all of the methods from the array
list ADT (Section 6.1). In addition, as we mentioned above, it also provides
functionality similar to that of the node list ADT through the use of its list iterator.
Performance of the java.util.LinkedList Class
The documentation for the java.util.LinkedList class makes it clear that
this class is implemented with a doubly linked list. Thus, all of the update
methods of the associated list iterator run in O(1) time each. Likewise, all of the
methods of the deque ADT also run in O(1) time each, since they merely involve
updating or querying the list at its ends. But the methods from the array list ADT
are also included in the java.util.LinkedList, which are, in general, not
well-suited to an implementation of a doubly linked list.
In particular, since a linked list does not allow for indexed access to its elements,
performing the operation get(i), to return the element at a given index i, requires
that we perform link "hopping" from one of the ends of the list, counting up or
down, until we locate the node storing the element with index i. As a slight
optimization, we observe that we can start this hopping from the closer end of the
list, thus achieving a running time that is
O(min(i + 1, n − i)),
352