Java API中LinkedList类中的“标题”

Question

In reading the LinkedList doc, I am a little puzzled by the uses of "header". Normally, the header is the first node in a linkedList. But here it looks like the 'header' is a dummy node in the list and it points to the first and last nodes of the list, thus making the LinkedList a circular one. Is that true?

private transient Entry<E> header = new Entry<E>(null, null, null);
public LinkedList() {
    header.next = header.previous = header;
}

public E getFirst() {
    if (size==0)
        throw new NoSuchElementException();

    return header.next.element;
}

public E getLast()  {
    if (size==0)
        throw new NoSuchElementException();

    return header.previous.element;
}

public E removeFirst() {
    return remove(header.next);
}

Answer 1

But here it looks like the 'header' is a dummy node in the list and it points to the first and last nodes of the list

That much is true

thus making the LinkedList a circular one.

That's not exactly true: structurally, the list is indeed circular, because the header "loops" it around. That is only an implementation detail, a common trick that lets you avoid declaring two things ( header and tailPiece ) instead of one. The fact that the same entry is used for both ends by itself is insufficient to make the list circular: there is no way for you to loop around the last node "from the outside", because the count prevents you from doing so.

Answer 2

You're right. header stores references to both the head and tail of the list. This helps in reducing cost of operations involving delete/add/view for both the ends of the list.

With the availability of references to both the ends, operations like getFirst , getLast , removeFirst , removeLast , addFirst , addLast etc. don't require list traversal.

Answer 3

A circular list is a cheap way to avoid storing both head and tail pointers in the top-level structure. I don't know about Java's LinkedList implementation, but this is certainly a trick pulled in eg the GCC implementation of std::list .

Answer 4

The implementation of LinkedList is using what's called s sentinel node. They've chosen to use one sentinel for both head and tail; other implmentations will use two separate sentinels.

In either case, the use of sentinels allow the rest of the implementation code to not deal with the null case. For example, consider adding a node. Without a sentinel:

Node newNode = ...;
if (header == null) {
  header = newNode;
  tail = newNode;
} else {
  newNode.previous = tail;
  tail.next = newNode;
  tail = newNode;
}

With the sentinel:

Node newNode = ...;
newNode.previous = sentinel.previous;
newNode.next = sentinel;
sentinel.previous = newNode;

Here's the Wikipedia article on Sentinel Nodes .