两种双向链表的首项插入与删除效率比较

这里说的两种双向链表是指带“sentinel”与不带“sentinel”的，其中带"sentinel"的多了一个"sentinel"节点，以空间换取了时间。两种链表如下图：

1.不带sentinel的：

下面是构造方法以及在首项插入和删除方法，从代码中可以看出没有sentinel的DList在插入时需要处理链表为空的情况，删除的时候需要处理链表为空以及链表只有一个元素的情况，比较麻烦。

public class DList1 {

  /**
   *  head references the first node.
   *  tail references the last node.
   */

  protected DListNode1 head;
  protected DListNode1 tail;
  protected long size;
  
  /* DList1 invariants:
   *  1)  head.prev == null.
   *  2)  tail.next == null.
   *  3)  For any DListNode1 x in a DList, if x.next == y and x.next != null,
   *      then y.prev == x.
   *  4)  For any DListNode1 x in a DList, if x.prev == y and x.prev != null,
   *      then y.next == x.
   *  5)  The tail can be accessed from the head by a sequence of "next"
   *      references.
   *  6)  size is the number of DListNode1s that can be accessed from the
   *      head by a sequence of "next" references.
   */

  /**
   *  DList1() constructor for an empty DList1.
   */
  public DList1() {
    head = null;
    tail = null;
    size = 0;
  }

  /**
   *  DList1() constructor for a one-node DList1.
   */
  public DList1(int a) {
    head = new DListNode1();
    tail = head;
    head.item = a;
    size = 1;
  }

  /**
   *  DList1() constructor for a two-node DList1.
   */
  public DList1(int a, int b) {
    head = new DListNode1();
    head.item = a;
    tail = new DListNode1();
    tail.item = b;
    head.next = tail;
    tail.prev = head;
    size = 2;
  }

  /**
   *  insertFront() inserts an item at the front of a DList1.
   */
  public void insertFront(int i) {
	  DListNode1 insertItem = new DListNode1(i);
	  if(head == null){
		  head = insertItem;
		  tail = insertItem;
	  }else{
		  insertItem.next = head;
		  head.prev = insertItem;
		  head = insertItem;
	  }
	  size++;
  }

  /**
   *  removeFront() removes the first item (and node) from a DList1.  If the
   *  list is empty, do nothing.
   */
  public void removeFront() {
	  if(size == 0){
		  return;
	  }
	  if(size == 1){
		  head = null;
		  tail = null;
	  }else{
		  head.next.prev = null;
		  head = head.next;
	  }
	  size--;
  }

2.下边是带sentinel的链表：

下边是构造方法以及首先插入与删除方法，注意构造方法中head的prev和next在链表没有元素的情况下是指向自身的，这一点非常重要，如果设置为null,就失去了这种链表的优势，还需要像第一种链表一样在插入和删除的时候考虑多种情况。

public class DList2 {

  /**
   *  head references the sentinel node.
   *
   */

  protected DListNode2 head;
  protected long size;

  /* DList2 invariants:
   *  1)  head != null.
   *  2)  For any DListNode2 x in a DList2, x.next != null.
   *  3)  For any DListNode2 x in a DList2, x.prev != null.
   *  4)  For any DListNode2 x in a DList2, if x.next == y, then y.prev == x.
   *  5)  For any DListNode2 x in a DList2, if x.prev == y, then y.next == x.
   *  6)  size is the number of DListNode2s, NOT COUNTING the sentinel
   *      (denoted by "head"), that can be accessed from the sentinel by
   *      a sequence of "next" references.
   */

  /**
   *  DList2() constructor for an empty DList2.
   */
  public DList2() {
    head = new DListNode2();
    head.item = Integer.MIN_VALUE;
    head.next = head;
    head.prev = head;
    size = 0;
  }

  /**
   *  DList2() constructor for a one-node DList2.
   */
  public DList2(int a) {
    head = new DListNode2();
    head.item = Integer.MIN_VALUE;
    head.next = new DListNode2();
    head.next.item = a;
    head.prev = head.next;
    head.next.prev = head;
    head.prev.next = head;
    size = 1;
  }

  /**
   *  DList2() constructor for a two-node DList2.
   */
  public DList2(int a, int b) {
    head = new DListNode2();
    head.item = Integer.MIN_VALUE;
    head.next = new DListNode2();
    head.next.item = a;
    head.prev = new DListNode2();
    head.prev.item = b;
    head.next.prev = head;
    head.next.next = head.prev;
    head.prev.next = head;
    head.prev.prev = head.next;
    size = 2;
  }

  /**
   *  insertFront() inserts an item at the front of a DList2.
   */
  public void insertFront(int i) {
	  DListNode2 insertItem = new DListNode2(i);
		  head.next.prev = insertItem;
		  insertItem.next = head.next;
		  insertItem.prev = head;
		  head.next = insertItem;
		  size++;
  }

  /**
   *  removeFront() removes the first item (and first non-sentinel node) from
   *  a DList2.  If the list is empty, do nothing.
   */
  public void removeFront() {
	  if(size == 0){
	  	return;
	  }
	  DListNode2 remove = head.next;
	  head.next = remove.next;
	  remove.next.prev = head;
	  size--;
  }