从jdk源码的角度重温链表

链表

由一系列节点组成的有序集合。

分为单向链表, 双向链表，循环链表

单向链表: 每一个节点都有一个指针指向下一个节点，最后一个节点的指针指向null

双向链表: 每一个节点都有两个指针(这里用p, n代表两个指针)，p指向前一个节点，n指向下一个节点。但第一个节点的p指向null, 最后一个节点的n指向null

循环链表: 每一个节点都有两个指针(这里用p, n代表两个指针), 第一个节点的p指向最后一个节点, 最后一个节点的n指向第一个节点。这样就形成了循环

java的LinkedList - 双向链表

这里以java的LinkedList的源码学习，不多说，先看源码

private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;

Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}

上面代码定义了一个类，代表一个节点的实体类，里面有3个成员变量，next用于指向下一个节点，prev用于指向前一个节点，item则是该节点承载的元素。

接下来，看一下它的一些添加元素的方法

public boolean add(E e) {
linkLast(e);
return true;
}

public void addFirst(E e) {
linkFirst(e);
}

public void addLast(E e) {
linkLast(e);
}

public void add(int index, E element) {
checkPositionIndex(index);

if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}

添加元素主要有4个方法，

- add和addLast其实是同一方法，都是在后面添加一个元素，所有都调用了linkLast(e)；

- addFirst则调用linkFirst(e)；

- add(index, element)这个方法是把元素添加某个位置，先调用checkPositionIndex(index)检查index是否在[0，size]之间, 接着判断想添加到index是否等于size,

因为位置是0开始，如果index == size，直接调用linkLast()放到最后一个位置即可。否则调用linkBefore方法

继续看linkLast，linkFirst，linkBefore这三个方法 ….

private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}

这个方法目的是把元素放到最前面，first和last是两个Node的成员变量，可以理解为用来记录第一个和最后一个的来临时变量。

先创建一个节点new Node<>(null, e, f)，要把元素放到最前面，此时newNode就是第一个节点，之前的第一个节点就成为newNode的下一个节点。

接着判断 f == null, 这里的f是指没添加之前的第一个节点，如果f为null, 那么当前添加就是第一个节点，也是最后一个节点，所以newNode赋值为last;

如果f不为null, 那么f的p指针就应该指向newNode。最后记录节点的变量+1。

void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}

linkLast方法目的是把元素放到最后面，思路跟linkFirst差不多， 临时变量l记录最后一个节点，然后创建一个新的节点，该节点p指向l, n指向null，

如果l为null, 没添加元素前为空集合，所以当前也是第一个节点，赋值为first;如果l不为null, 那么 l 的n应该指向新的节点。最后节点数+1.

void linkBefore(E e, Node<E> succ) {
final Node<E> pred = succ.prev;
final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}

linkBefore方法的目的是将元素e放到一个指定的节点之前。 succ是这个指定的节点。首先用临时变量pred记录succ的前一个节点,

接着创建一个新的节点，p指向pred, n指向succ, succ的p指针就指向这个新的节点newNode。如果pred 为null, succ的前一个节点为null,

那么newNode就是第一个节点;如果pred不为null, pred的n指针应该指向newNode。最后节点数+1

添加分析完了，接下来看看移除

public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}

public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}

public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}

4000
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}

removeFirst, removeLast 分别调用unlinkFirst(f), unlinkLast(l);

看remove方法，遍历链表，从first开始, 找到和o相等的元素，调用unlink方法完成移除。

private E unlinkFirst(Node<E> f) {
final E element = f.item;
final Node<E> next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}

f是第一个节点，f.item和f.next分别临时赋值给element和next，接着f.item和f.next都设为null,就意味着移除了第一个节点,

那么next这个节点就是第一节点了，赋值给first; 如果next为null, 那么last为null,说明现在链表整个为空啦;如果next不为null,将next的p指针指向null。

private E unlinkLast(Node<E> l) {
final E element = l.item;
final Node<E> prev = l.prev;
l.item = null;
l.prev = null; // help GC
last = prev;
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}

l是最后一个节点，l.item和l.prev分别临时赋值给element和prev,接着l.item和l.prev都设为null,就意味着移除了最后一个节点了,

那么prev这个节点就是最后一个节点了,赋值给last; 如果prev为null, 那么first也为null,说明现在链表整个为空啦;如果prev不为null,将prev的n指针指向null。

E unlink(Node<E> x) {
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;

if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}

if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}

x.item = null;
size--;
modCount++;
return element;
}

移除某个节点： x.item， x.next, x.prev分别临时赋值给element, next和prev; 重新调整next 和prev节点,

如果prev为null, 那么next节点就是第一个节点;如果prev不为null, prev的n指向next, x的p设为null;

如果next为null, 那么prev节点就是最后一个节点; 如果next不为null, next的p指向prev, x的next设为null；

最后把x.item设为null,移除当前, size–代表节点数减1, modCount记录的是链表的操作次数，所以怎么都是加1。

到此， 双向链表的实现就基本完成啦。如果要实现循环链表，在双向链表的基础上，把第一个节点的p指向最后一个, 把最后一个节点的n指向第一个节点。